Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "LanaiDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", ";", "}", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "ConstantSDNode", "*", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "if", "(", "ConstNode", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "Lanai", "::", "R0", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "if", "(", "ConstNode", "->", "isAllOnesValue", "(", ")", ")", "{", "SDValue", "New", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "Lanai", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "return", "ReplaceNode", "(", "Node", ",", "New", ".", "getNode", "(", ")", ")", ";", "}", "}", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "selectFrameIndex", "(", "Node", ")", ";", "return", ";", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"== \"", "\"\\n\"", "0", "ISD::Constant", "MVT::i32", "Lanai::R0", "MVT::i32", "Lanai::R1", "MVT::i32", "ISD::FrameIndex" ]

[]

[ "<s>", "unsigned", "getPrefetchDistance", "(", ")", "const", "override", "{", "return", "4500", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

[ "SystemZ", "4500" ]

[]

[ "<s>", "static", "machine_mode", "zero_call_used_regno_mode", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", ")", "return", "SImode", ";", "else", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "return", "V4SFmode", ";", "else", "if", "(", "MASK_REGNO_P", "(", "regno", ")", ")", "return", "HImode", ";", "else", "if", "(", "MMX_REGNO_P", "(", "regno", ")", ")", "return", "V2SImode", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "machine_mode", "that", "is", "used", "to", "zero", "register", "REGNO", "." ]

[ "i386" ]

[]

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

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

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

[]

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

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

[ "X86" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "unsigned", "SGPRLimit", "=", "getNumSGPRsAllowed", "(", "STI", ".", "getGeneration", "(", ")", ",", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VGPRLimit", "=", "getNumVGPRsAllowed", "(", "STI", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VSLimit", "=", "SGPRLimit", "+", "VGPRLimit", ";", "if", "(", "SGPRPressureSets", ".", "test", "(", "Idx", ")", "&&", "VGPRPressureSets", ".", "test", "(", "Idx", ")", ")", "{", "return", "VSLimit", ";", "}", "if", "(", "SGPRPressureSets", ".", "test", "(", "Idx", ")", ")", "return", "SGPRLimit", ";", "return", "VGPRLimit", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

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

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isInlineAsmSourceOfDivergence", "(", "const", "CallInst", "*", "CI", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ")", "const", "{", "if", "(", "Indices", ".", "size", "(", ")", ">", "1", ")", "return", "true", ";", "const", "DataLayout", "&", "DL", "=", "CI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TargetLowering", "::", "AsmOperandInfoVector", "TargetConstraints", "=", "TLI", "->", "ParseConstraints", "(", "DL", ",", "ST", "->", "getRegisterInfo", "(", ")", ",", "*", "CI", ")", ";", "const", "int", "TargetOutputIdx", "=", "Indices", ".", "empty", "(", ")", "?", "-", "1", ":", "Indices", "[", "0", "]", ";", "int", "OutputIdx", "=", "0", ";", "for", "(", "auto", "&", "TC", ":", "TargetConstraints", ")", "{", "if", "(", "TC", ".", "Type", "!=", "InlineAsm", "::", "isOutput", ")", "continue", ";", "if", "(", "TargetOutputIdx", "!=", "-", "1", "&&", "TargetOutputIdx", "!=", "OutputIdx", "++", ")", "continue", ";", "TLI", "->", "ComputeConstraintToUse", "(", "TC", ",", "SDValue", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", "->", "getRegForInlineAsmConstraint", "(", "TRI", ",", "TC", ".", "ConstraintCode", ",", "TC", ".", "ConstraintVT", ")", ".", "second", ";", "if", "(", "!", "RC", "||", "!", "TRI", "->", "isSGPRClass", "(", "RC", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Analyze", "if", "the", "results", "of", "inline", "asm", "are", "divergent", "." ]

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

[]

[ "<s>", "size_t", "ARMToTHMStub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "getMask", "(", ")", "const", "{", "return", "Mask", "<<", "Shift", ";", "}", "</s>" ]

[ "Return", "the", "mask", "used", "by", "this", "recipe", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "assert", "(", "0", "&&", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SREM", ":", "return", "LowerSREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "R600", "0", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SDIV", "ISD::SREM", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::BRCOND", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::FrameIndex", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::UDIVREM", "ISD::UINT_TO_FP" ]

[]

[ "<s>", "StringRef", "RISCVMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_RISCV_LO", ":", "return", "\"lo\"", ";", "case", "VK_RISCV_HI", ":", "return", "\"hi\"", ";", "case", "VK_RISCV_PCREL_LO", ":", "return", "\"pcrel_lo\"", ";", "case", "VK_RISCV_PCREL_HI", ":", "return", "\"pcrel_hi\"", ";", "case", "VK_RISCV_GOT_HI", ":", "return", "\"got_pcrel_hi\"", ";", "case", "VK_RISCV_TPREL_LO", ":", "return", "\"tprel_lo\"", ";", "case", "VK_RISCV_TPREL_HI", ":", "return", "\"tprel_hi\"", ";", "case", "VK_RISCV_TPREL_ADD", ":", "return", "\"tprel_add\"", ";", "case", "VK_RISCV_TLS_GOT_HI", ":", "return", "\"tls_ie_pcrel_hi\"", ";", "case", "VK_RISCV_TLS_GD_HI", ":", "return", "\"tls_gd_pcrel_hi\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "RISCV", "RISCV", "\"Invalid ELF symbol kind\"", "RISCV", "\"lo\"", "RISCV", "\"hi\"", "RISCV", "\"pcrel_lo\"", "RISCV", "\"pcrel_hi\"", "RISCV", "\"got_pcrel_hi\"", "RISCV", "\"tprel_lo\"", "RISCV", "\"tprel_hi\"", "RISCV", "\"tprel_add\"", "RISCV", "\"tls_ie_pcrel_hi\"", "RISCV", "\"tls_gd_pcrel_hi\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "!", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "{", "initialize", "(", "MF", ")", ";", "checkingIllegalXADD", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", "||", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "R600", "SI", "16", "0", "1", "2" ]

[]

[ "<s>", "size_t", "ARMToARMStub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "ARMTTI", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "Bits", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "0", "||", "Bits", ">", "32", ")", "return", "4", ";", "int32_t", "SImmVal", "=", "Imm", ".", "getSExtValue", "(", ")", ";", "uint32_t", "ZImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "ST", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "else", "if", "(", "ST", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "else", "{", "if", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "256", ")", "return", "1", ";", "if", "(", "(", "~", "ZImmVal", "<", "256", ")", "||", "ARM_AM", "::", "isThumbImmShiftedVal", "(", "ZImmVal", ")", ")", "return", "2", ";", "return", "3", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "ARM", "ARMTTI::getIntImmCost", "0", "32", "4", "0", "65536", "ARM_AM::getSOImmVal", "1", "ARM_AM::getSOImmVal", "1", "1", "2", "3", "0", "65536", "ARM_AM::getT2SOImmVal", "1", "ARM_AM::getT2SOImmVal", "1", "1", "2", "3", "0", "256", "1", "256", "ARM_AM::isThumbImmShiftedVal", "2", "3", "2" ]

[]

[ "<s>", "void", "xstormy16_emit_cbranch", "(", "enum", "rtx_code", "code", ",", "rtx", "loc", ")", "{", "rtx", "op0", "=", "xstormy16_compare_op0", ";", "rtx", "op1", "=", "xstormy16_compare_op1", ";", "rtx", "condition_rtx", ",", "loc_ref", ",", "branch", ",", "cy_clobber", ";", "rtvec", "vec", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "gcc_assert", "(", "mode", "==", "HImode", "||", "mode", "==", "SImode", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "code", "==", "GT", "||", "code", "==", "LE", "||", "code", "==", "GTU", "||", "code", "==", "LEU", ")", ")", "{", "int", "unsigned_p", "=", "(", "code", "==", "GTU", "||", "code", "==", "LEU", ")", ";", "int", "gt_p", "=", "(", "code", "==", "GT", "||", "code", "==", "GTU", ")", ";", "rtx", "lab", "=", "NULL_RTX", ";", "if", "(", "gt_p", ")", "lab", "=", "gen_label_rtx", "(", ")", ";", "xstormy16_emit_cbranch", "(", "unsigned_p", "?", "LTU", ":", "LT", ",", "gt_p", "?", "lab", ":", "loc", ")", ";", "xstormy16_emit_cbranch", "(", "gt_p", "?", "NE", ":", "EQ", ",", "loc", ")", ";", "if", "(", "gt_p", ")", "emit_label", "(", "lab", ")", ";", "return", ";", "}", "else", "if", "(", "mode", "==", "SImode", "&&", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "op1", "!=", "const0_rtx", ")", "{", "rtx", "lab", "=", "NULL_RTX", ";", "int", "num_words", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "BITS_PER_WORD", ";", "int", "i", ";", "if", "(", "code", "==", "EQ", ")", "lab", "=", "gen_label_rtx", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_words", "-", "1", ";", "i", "++", ")", "{", "xstormy16_compare_op0", "=", "simplify_gen_subreg", "(", "word_mode", ",", "op0", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "xstormy16_compare_op1", "=", "simplify_gen_subreg", "(", "word_mode", ",", "op1", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "xstormy16_emit_cbranch", "(", "NE", ",", "code", "==", "EQ", "?", "lab", ":", "loc", ")", ";", "}", "xstormy16_compare_op0", "=", "simplify_gen_subreg", "(", "word_mode", ",", "op0", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "xstormy16_compare_op1", "=", "simplify_gen_subreg", "(", "word_mode", ",", "op1", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "xstormy16_emit_cbranch", "(", "code", ",", "loc", ")", ";", "if", "(", "code", "==", "EQ", ")", "emit_label", "(", "lab", ")", ";", "return", ";", "}", "if", "(", "mode", "!=", "HImode", ")", "{", "rtx", "tmp", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "tmp", ",", "op0", ")", ";", "op0", "=", "tmp", ";", "}", "condition_rtx", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op0", ",", "op1", ")", ";", "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "loc", ")", ";", "branch", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition_rtx", ",", "loc_ref", ",", "pc_rtx", ")", ")", ";", "cy_clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "BImode", ")", ")", ";", "if", "(", "mode", "==", "HImode", ")", "vec", "=", "gen_rtvec", "(", "2", ",", "branch", ",", "cy_clobber", ")", ";", "else", "if", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "vec", "=", "gen_rtvec", "(", "2", ",", "branch", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "op0", ")", ")", ";", "else", "{", "rtx", "sub", ";", "sub", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "gen_rtx_MINUS", "(", "SImode", ",", "op0", ",", "op1", ")", ")", ";", "sub", "=", "gen_rtx_CLOBBER", "(", "SImode", ",", "op0", ")", ";", "vec", "=", "gen_rtvec", "(", "3", ",", "branch", ",", "sub", ",", "cy_clobber", ")", ";", "}", "emit_jump_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "branch", "of", "kind", "CODE", "to", "location", "LOC", "." ]

[ "stormy16", "0", "1", "2", "2", "3" ]

[]

[ "<s>", "bool", "isFPImm", "(", ")", "const", "{", "return", "Kind", "==", "k_FPImm", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "tree", "arm_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", ")", "{", "valist", "=", "arm_extract_valist_ptr", "(", "valist", ")", ";", "return", "std_gimplify_va_arg_expr", "(", "valist", ",", "type", ",", "pre_p", ",", "post_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLIFY_VA_ARG_EXPR", "." ]

[ "arm" ]

[]

[ "<s>", "const", "AVRMCExpr", "*", "AVRMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "bool", "Negated", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "AVRMCExpr", "(", "Kind", ",", "Expr", ",", "Negated", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Nyuzi Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Nyuzi", "\"Nyuzi Assembly Printer\"" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "VARegSaveSize", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasStackFrame", "(", ")", ")", "{", "if", "(", "NumBytes", "!=", "0", ")", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "else", "{", "const", "unsigned", "*", "CSRegs", "=", "getCalleeSavedRegs", "(", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "--", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "MBBI", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "MBBI", ",", "CSRegs", ")", ")", "++", "MBBI", ";", "}", "NumBytes", "-=", "(", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", "+", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "NumBytes", "=", "AFI", "->", "getFramePtrSpillOffset", "(", ")", "-", "NumBytes", ";", "if", "(", "NumBytes", ")", "emitThumbRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "ARM", "::", "SP", ",", "FramePtr", ",", "-", "NumBytes", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "else", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", "&&", "&", "MBB", ".", "front", "(", ")", "!=", "MBBI", "&&", "prior", "(", "MBBI", ")", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", ")", "{", "MachineBasicBlock", "::", "iterator", "PMBBI", "=", "prior", "(", "MBBI", ")", ";", "emitSPUpdate", "(", "MBB", ",", "PMBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "else", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "NumBytes", ")", ";", "}", "}", "if", "(", "VARegSaveSize", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ")", ".", "addReg", "(", "ARM", "::", "R3", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "this", ",", "VARegSaveSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tBX_RET_vararg", ")", ")", ".", "addReg", "(", "ARM", "::", "R3", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "ARM", "ARM::tBX_RET", "ARM::tPOP_RET", "\"Can only insert epilog into returning blocks\"", "ARM", "ARM", "0", "ARM::SP", "ARM::tMOVtgpr2gpr", "ARM::SP", "ARM::tBX_RET", "ARM::tPOP", "ARM::tPOP", "ARM::R3", "ARM::tBX_RET_vararg", "ARM::R3" ]

[]

[ "<s>", "DecodeStatus", "P2Disassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "cond", "=", "fieldFromInstruction", "(", "Insn", ",", "28", ",", "4", ")", ";", "Instr", ".", "setFlags", "(", "(", "Instr", ".", "getFlags", "(", ")", "&", "0xf", ")", "|", "cond", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"get instruction: \"", "<<", "Insn", "<<", "\"\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableP232", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "P2", "P2", "28", "4", "0xf", "\"get instruction: \"", "\"\\n\"", "P2" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "isConditionalBranch", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "Bcc", "&&", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "A64CC", "::", "AL", ")", "return", "false", ";", "return", "MCInstrAnalysis", "::", "isConditionalBranch", "(", "Inst", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64::Bcc", "0", "A64CC::AL" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "Insts", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "ARM" ]

[]

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

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_setup", "(", "gcall", "*", "call", ",", "offload_attrs", "*", "oa", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "!=", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "!", "integer_zerop", "(", "ref_to_res", ")", ")", "var", "=", "build_simple_mem_ref", "(", "ref_to_res", ")", ";", "}", "if", "(", "level", "==", "GOMP_DIM_WORKER", "||", "(", "level", "==", "GOMP_DIM_VECTOR", "&&", "oa", "->", "vector_length", ">", "PTX_WARP_SIZE", ")", ")", "{", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "5", ")", ";", "tree", "call", "=", "nvptx_get_shared_red_addr", "(", "TREE_TYPE", "(", "var", ")", ",", "offset", ",", "level", "==", "GOMP_DIM_VECTOR", ")", ";", "tree", "ptr", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "call", ")", ")", ";", "gimplify_assign", "(", "ptr", ",", "call", ",", "&", "seq", ")", ";", "tree", "ref", "=", "build_simple_mem_ref", "(", "ptr", ")", ";", "TREE_THIS_VOLATILE", "(", "ref", ")", "=", "1", ";", "gimplify_assign", "(", "ref", ",", "var", ",", "&", "seq", ")", ";", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "var", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_SETUP", "." ]

[ "nvptx", "2", "3", "1", "5", "1" ]

[]

[ "<s>", "static", "bool", "mips_valid_lo_sum_p", "(", "enum", "mips_symbol_type", "symbol_type", ",", "machine_mode", "mode", ")", "{", "if", "(", "mips_symbol_insns", "(", "symbol_type", ",", "mode", ")", "==", "0", ")", "return", "false", ";", "if", "(", "mips_lo_relocs", "[", "symbol_type", "]", "==", "NULL", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYMBOL_TYPE", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "void", "rs6000_elf_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "const", "char", "*", "section", "=", "\".ctors\"", ";", "char", "buf", "[", "16", "]", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "sprintf", "(", "buf", ",", "\".ctors.%.5u\"", ",", "MAX_INIT_PRIORITY", "-", "priority", ")", ";", "section", "=", "buf", ";", "}", "switch_to_section", "(", "get_section", "(", "section", ",", "SECTION_WRITE", ",", "NULL", ")", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "if", "(", "TARGET_RELOCATABLE", ")", "{", "fputs", "(", "\"\\t.long (\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "symbol", ")", ";", "fputs", "(", "\")@fixup\\n\"", ",", "asm_out_file", ")", ";", "}", "else", "assemble_integer", "(", "symbol", ",", "POINTER_SIZE", "/", "BITS_PER_UNIT", ",", "POINTER_SIZE", ",", "1", ")", ";", "}", "</s>" ]

[ "Record", "an", "element", "in", "the", "table", "of", "global", "constructors", ".", "SYMBOL", "is", "a", "SYMBOL_REF", "of", "the", "function", "to", "be", "called", ";", "PRIORITY", "is", "a", "number", "between", "0", "and", "MAX_INIT_PRIORITY", ".", "This", "differs", "from", "default_named_section_asm_out_constructor", "in", "that", "we", "have", "special", "handling", "for", "-mrelocatable", "." ]

[ "rs6000", "\".ctors\"", "16", "\".ctors.%.5u\"", "\"\\t.long (\"", "\")@fixup\\n\"", "1" ]

[]

[ "<s>", "static", "hash_set", "<", "set_info", "*", ">", "get_all_sets", "(", "set_info", "*", "set", ",", "bool", "real_p", ",", "bool", "phi_p", ",", "bool", "param_p", ")", "{", "if", "(", "real_p", "&&", "phi_p", "&&", "param_p", ")", "return", "get_all_sets", "(", "safe_dyn_cast", "<", "phi_info", "*", ">", "(", "set", ")", ",", "REAL_SET", "|", "PHI_SET", "|", "BB_HEAD_SET", "|", "BB_END_SET", ")", ";", "else", "if", "(", "real_p", "&&", "param_p", ")", "return", "get_all_sets", "(", "safe_dyn_cast", "<", "phi_info", "*", ">", "(", "set", ")", ",", "REAL_SET", "|", "BB_HEAD_SET", "|", "BB_END_SET", ")", ";", "else", "if", "(", "real_p", ")", "return", "get_all_sets", "(", "safe_dyn_cast", "<", "phi_info", "*", ">", "(", "set", ")", ",", "REAL_SET", ")", ";", "return", "hash_set", "<", "set_info", "*", ">", "(", ")", ";", "}", "</s>" ]

[ "Recursively", "find", "all", "define", "instructions", ".", "The", "kind", "of", "instruction", "is", "specified", "by", "the", "DEF_TYPE", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"MIPS16 Hard Float Pass\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS16 Hard Float Pass\"" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "X86RegisterInfo", "*", "X86RI", "=", "TM", "->", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "StackAlignment", "=", "X86RI", "->", "getStackAlignment", "(", ")", ";", "for", "(", "unsigned", "RegNum", "=", "TargetRegisterInfo", "::", "FirstVirtualRegister", ";", "RegNum", "<", "RI", ".", "getLastVirtReg", "(", ")", ";", "++", "RegNum", ")", "if", "(", "RI", ".", "getRegClass", "(", "RegNum", ")", "->", "getAlignment", "(", ")", ">", "StackAlignment", ")", "{", "FuncInfo", "->", "setReserveFP", "(", "true", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonMCInstrInfo", "::", "isExtended", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "uint64_t", "const", "F", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ";", "}", "</s>" ]

[ "Test", "if", "the", "given", "EVT", "is", "extended", "(", "as", "opposed", "to", "being", "simple", ")", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "HexagonII::ExtendedPos", "HexagonII::ExtendedMask" ]

[]

[ "<s>", "static", "hashval_t", "unspec_prof_hash", "(", "const", "void", "*", "x", ")", "{", "const_rtx", "u", "=", "(", "const_rtx", ")", "x", ";", "const_rtx", "s1", "=", "XVECEXP", "(", "u", ",", "0", ",", "1", ")", ";", "return", "(", "htab_hash_string", "(", "XSTR", "(", "XVECEXP", "(", "u", ",", "0", ",", "0", ")", ",", "0", ")", ")", "^", "(", "s1", "->", "code", "==", "SYMBOL_REF", "?", "htab_hash_string", "(", "XSTR", "(", "s1", ",", "0", ")", ")", ":", "0", ")", ")", ";", "}", "</s>" ]

[ "Hash", "function", "for", "UNSPEC_PROF", "htab", ".", "Use", "both", "the", "caller", "'s", "name", "and", "the", "callee", "'s", "name", "(", "if", "known", ")", "." ]

[ "arc", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "SICSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "DefaultSubtarget", ";", "}", "</s>" ]

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

[ "SIC", "SIC" ]

[]

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

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

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

[]

[ "<s>", "StringRef", "SIRegisterInfo", "::", "getRegAsmName", "(", "unsigned", "Reg", ")", "const", "{", "if", "(", "Reg", ">=", "BeginReg", "&&", "Reg", "<=", "EndReg", ")", "{", "\\", "unsigned", "Index", "=", "Reg", "-", "BeginReg", ";", "\\", "assert", "(", "Index", "<", "array_lengthof", "(", "RegTable", ")", ")", ";", "\\", "return", "RegTable", "[", "Index", "]", ";", "\\", "}", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0", ",", "AMDGPU", "::", "VGPR255", ",", "VGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0", ",", "AMDGPU", "::", "SGPR105", ",", "SGPR32RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1", ",", "AMDGPU", "::", "VGPR254_VGPR255", ",", "VGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1", ",", "AMDGPU", "::", "SGPR104_SGPR105", ",", "SGPR64RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2", ",", "AMDGPU", "::", "VGPR253_VGPR254_VGPR255", ",", "VGPR96RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3", ",", "AMDGPU", "::", "VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "AMDGPU", "::", "SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR128RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", ",", "AMDGPU", "::", "VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", ",", "AMDGPU", "::", "VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", ",", "VGPR512RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", ",", "AMDGPU", "::", "SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR256RegNames", ")", ";", "REG_RANGE", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", ",", "AMDGPU", "::", "SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", ",", "SGPR512RegNames", ")", ";", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "FLAT_SCR", ":", "return", "\"flat_scratch\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "return", "\"flat_scratch_lo\"", ";", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "return", "\"flat_scratch_hi\"", ";", "default", ":", "return", "TargetRegisterInfo", "::", "getRegAsmName", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "assembly", "name", "for", "Reg", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR0", "AMDGPU::VGPR255", "AMDGPU::SGPR0", "AMDGPU::SGPR105", "AMDGPU::VGPR0_VGPR1", "AMDGPU::VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1", "AMDGPU::SGPR104_SGPR105", "AMDGPU::VGPR0_VGPR1_VGPR2", "AMDGPU::VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3", "AMDGPU::VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7", "AMDGPU::VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::VGPR0_VGPR1_VGPR2_VGPR3_VGPR4_VGPR5_VGPR6_VGPR7_VGPR8_VGPR9_VGPR10_VGPR11_VGPR12_VGPR13_VGPR14_VGPR15", "AMDGPU::VGPR240_VGPR241_VGPR242_VGPR243_VGPR244_VGPR245_VGPR246_VGPR247_VGPR248_VGPR249_VGPR250_VGPR251_VGPR252_VGPR253_VGPR254_VGPR255", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7", "AMDGPU::SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3_SGPR4_SGPR5_SGPR6_SGPR7_SGPR8_SGPR9_SGPR10_SGPR11_SGPR12_SGPR13_SGPR14_SGPR15", "AMDGPU::SGPR88_SGPR89_SGPR90_SGPR91_SGPR92_SGPR93_SGPR94_SGPR95_SGPR96_SGPR97_SGPR98_SGPR99_SGPR100_SGPR101_SGPR102_SGPR103", "AMDGPU::FLAT_SCR", "\"flat_scratch\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_HI", "\"flat_scratch_hi\"" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "emitRawBytes", "(", "StringRef", "Data", ")", "{", "MCTargetStreamer", "::", "emitRawBytes", "(", "Data", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "Streamer", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ";", "const", "char", "*", "Directive", "=", "MAI", "->", "getData8bitsDirective", "(", ")", ";", "unsigned", "NumElements", "=", "Data", ".", "size", "(", ")", ";", "const", "unsigned", "MaxLen", "=", "40", ";", "unsigned", "NumChunks", "=", "1", "+", "(", "(", "NumElements", "-", "1", ")", "/", "MaxLen", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "NumChunks", ";", "++", "I", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "const", "char", "*", "Label", "=", "Directive", ";", "for", "(", "auto", "It", "=", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "I", "*", "MaxLen", ")", ",", "End", "=", "(", "I", "==", "NumChunks", "-", "1", ")", "?", "Data", ".", "bytes_end", "(", ")", ":", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "(", "I", "+", "1", ")", "*", "MaxLen", ")", ";", "It", "!=", "End", ";", "++", "It", ")", "{", "OS", "<<", "Label", "<<", "(", "unsigned", ")", "*", "It", ";", "if", "(", "Label", "==", "Directive", ")", "Label", "=", "\",\"", ";", "}", "Streamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "NVPTX", "NVPTX", "40", "1", "1", "0", "128", "1", "1", "\",\"" ]

[]

[ "<s>", "static", "const", "char", "*", "detect_processor_freebsd", "(", "void", ")", "{", "return", "\"powerpc\"", ";", "}", "</s>" ]

[ "Currently", "returns", "default", "powerpc", "." ]

[ "rs6000", "\"powerpc\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getBaseAndOffsetPosition", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "BasePos", ",", "unsigned", "&", "OffsetPos", ")", "const", "{", "if", "(", "isMemOp", "(", "MI", ")", ")", "{", "BasePos", "=", "0", ";", "OffsetPos", "=", "1", ";", "}", "else", "if", "(", "MI", "->", "mayStore", "(", ")", ")", "{", "BasePos", "=", "0", ";", "OffsetPos", "=", "1", ";", "}", "else", "if", "(", "MI", "->", "mayLoad", "(", ")", ")", "{", "BasePos", "=", "1", ";", "OffsetPos", "=", "2", ";", "}", "else", "return", "false", ";", "if", "(", "isPredicated", "(", "*", "MI", ")", ")", "{", "BasePos", "++", ";", "OffsetPos", "++", ";", "}", "if", "(", "isPostIncrement", "(", "MI", ")", ")", "{", "BasePos", "++", ";", "OffsetPos", "++", ";", "}", "if", "(", "!", "MI", "->", "getOperand", "(", "BasePos", ")", ".", "isReg", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OffsetPos", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "contains", "a", "base", "register", "and", "offset", "." ]

[ "Hexagon", "Hexagon", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "ARMFastISel", "::", "fastLowerArguments", "(", ")", "{", "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "const", "Function", "*", "F", "=", "FuncInfo", ".", "Fn", ";", "if", "(", "F", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "CallingConv", "::", "ID", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "return", "false", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "ARM_AAPCS", ":", "case", "CallingConv", "::", "ARM_APCS", ":", "case", "CallingConv", "::", "Swift", ":", "break", ";", "}", "for", "(", "const", "Argument", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "getArgNo", "(", ")", ">=", "4", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "break", ";", "default", ":", "return", "false", ";", "}", "}", "static", "const", "MCPhysReg", "GPRArgRegs", "[", "]", "=", "{", "ARM", "::", "R0", ",", "ARM", "::", "R1", ",", "ARM", "::", "R2", ",", "ARM", "::", "R3", "}", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "rGPRRegClass", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->", "arg_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "ArgNo", "=", "I", "->", "getArgNo", "(", ")", ";", "unsigned", "SrcReg", "=", "GPRArgRegs", "[", "ArgNo", "]", ";", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "updateValueMap", "(", "&", "*", "I", ",", "ResultReg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "argument", "lowering", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "4", "MVT::i8", "MVT::i16", "MVT::i32", "ARM::R0", "ARM::R1", "ARM::R2", "ARM::R3", "ARM::rGPRRegClass" ]

[]

[ "<s>", "rtx", "spu_gen_subreg", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "mode", ")", "return", "x", ";", "return", "gen_rtx_SUBREG", "(", "mode", ",", "x", ",", "0", ")", ";", "}", "</s>" ]

[ "Make", "a", "subreg", ",", "stripping", "any", "existing", "subreg", ".", "We", "could", "possibly", "just", "call", "simplify_subreg", ",", "but", "in", "this", "case", "we", "know", "what", "we", "want", "." ]

[ "spu", "0" ]

[]

[ "<s>", "static", "void", "nios2_custom_check_insns", "(", "void", ")", "{", "unsigned", "int", "i", ",", "j", ";", "bool", "errors", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "i", "++", ")", "if", "(", "N2FPU_ENABLED_P", "(", "i", ")", "&&", "N2FPU_DOUBLE_P", "(", "i", ")", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "j", "++", ")", "if", "(", "N2FPU_DOUBLE_REQUIRED_P", "(", "j", ")", "&&", "!", "N2FPU_ENABLED_P", "(", "j", ")", ")", "{", "error", "(", "\"switch %<-mcustom-%s%> is required for double \"", "\"precision floating point\"", ",", "N2FPU_NAME", "(", "j", ")", ")", ";", "errors", "=", "true", ";", "}", "break", ";", "}", "if", "(", "!", "flag_unsafe_math_optimizations", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "i", "++", ")", "if", "(", "N2FPU_ENABLED_P", "(", "i", ")", "&&", "N2FPU_UNSAFE_P", "(", "i", ")", ")", "warning", "(", "0", ",", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-funsafe-math-optimizations is specified\"", ",", "N2FPU_NAME", "(", "i", ")", ")", ";", "if", "(", "!", "flag_finite_math_only", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "i", "++", ")", "if", "(", "N2FPU_ENABLED_P", "(", "i", ")", "&&", "N2FPU_FINITE_P", "(", "i", ")", ")", "warning", "(", "0", ",", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-ffinite-math-only is specified\"", ",", "N2FPU_NAME", "(", "i", ")", ")", ";", "if", "(", "flag_errno_math", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "nios2_fpu_insn", ")", ";", "i", "++", ")", "if", "(", "N2FPU_ENABLED_P", "(", "i", ")", "&&", "N2FPU_NO_ERRNO_P", "(", "i", ")", ")", "warning", "(", "0", ",", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-fno-math-errno is specified\"", ",", "N2FPU_NAME", "(", "i", ")", ")", ";", "if", "(", "errors", "||", "custom_code_conflict", ")", "fatal_error", "(", "input_location", ",", "\"conflicting use of -mcustom switches, target attributes, \"", "\"and/or __builtin_custom_ functions\"", ")", ";", "}", "</s>" ]

[ "Check", "and", "signal", "some", "warnings/errors", "on", "FPU", "insn", "options", "." ]

[ "nios2", "0", "0", "\"switch %<-mcustom-%s%> is required for double \"", "\"precision floating point\"", "0", "0", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-funsafe-math-optimizations is specified\"", "0", "0", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-ffinite-math-only is specified\"", "0", "0", "\"switch %<-mcustom-%s%> has no effect unless \"", "\"-fno-math-errno is specified\"", "\"conflicting use of -mcustom switches, target attributes, \"", "\"and/or __builtin_custom_ functions\"" ]

[]

[ "<s>", "const", "SystemZSubtarget", "*", "SystemZTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "softFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsBool", "(", ")", ";", "if", "(", "softFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "SystemZSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"+soft-float\"", "\",+soft-float\"", "SystemZ" ]

[]

[ "<s>", "static", "type_suffix_index", "find_type_suffix_for_scalar_type", "(", "const_tree", "type", ")", "{", "for", "(", "unsigned", "int", "suffix_i", "=", "0", ";", "suffix_i", "<", "NUM_TYPE_SUFFIXES", ";", "++", "suffix_i", ")", "if", "(", "!", "type_suffixes", "[", "suffix_i", "]", ".", "bool_p", ")", "{", "vector_type_index", "vector_i", "=", "type_suffixes", "[", "suffix_i", "]", ".", "vector_type", ";", "if", "(", "matches_type_p", "(", "scalar_types", "[", "vector_i", "]", ",", "type", ")", ")", "return", "type_suffix_index", "(", "suffix_i", ")", ";", "}", "return", "NUM_TYPE_SUFFIXES", ";", "}", "</s>" ]

[ "If", "TYPE", "is", "a", "valid", "SVE", "element", "type", ",", "return", "the", "corresponding", "type", "suffix", ",", "otherwise", "return", "NUM_TYPE_SUFFIXES", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "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", ".", "getTarget", "(", ")", ".", "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", "::", "tLDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARMCC::CondCodes", "4", "ARM::tLDRpci" ]

[]

[ "<s>", "void", "WebAssemblyDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "(", "void", ")", "VT", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"== \"", "\"\\n\"", "1", "0" ]

[]

[ "<s>", "bool", "TL45PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTL45ISelDag", "(", "getTL45TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45", "TL45" ]

[]

[ "<s>", "unsigned", "BlackfinRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasFP", "(", "MF", ")", "?", "BF", "::", "FP", ":", "BF", "::", "SP", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::FP", "BF::SP" ]

[]

[ "<s>", "void", "or1k_expand_compare", "(", "rtx", "*", "operands", ")", "{", "rtx", "sr_f", "=", "gen_rtx_REG", "(", "BImode", ",", "SR_F_REGNUM", ")", ";", "if", "(", "!", "TARGET_SFIMM", ")", "XEXP", "(", "operands", "[", "0", "]", ",", "1", ")", "=", "force_reg", "(", "SImode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "1", ")", ")", ";", "PUT_MODE", "(", "operands", "[", "0", "]", ",", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "sr_f", ",", "operands", "[", "0", "]", ")", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "sr_f", ",", "const0_rtx", ")", ";", "operands", "[", "1", "]", "=", "sr_f", ";", "operands", "[", "2", "]", "=", "const0_rtx", ";", "}", "</s>" ]

[ "Used", "to", "expand", "patterns", "``", "movsicc", "''", ",", "``", "movqicc", "''", ",", "``", "movhicc", "''", ",", "``", "cstoresi4", "''", "and", "``", "cbranchsi4", "''", ".", "Expands", "a", "comparison", "where", "OPERANDS", "is", "an", "array", "of", "RTX", "describing", "the", "comparison", ".", "The", "first", "argument", "OPERANDS", "[", "0", "]", "is", "the", "operator", "and", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "are", "the", "operands", ".", "Split", "out", "the", "compare", "into", "SR", "[", "F", "]", "and", "return", "a", "new", "operation", "in", "OPERANDS", "[", "0", "]", ".", "The", "inputs", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "are", "not", "directly", "used", ",", "only", "overridden", "." ]

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

[]

[ "<s>", "int", "microblaze_is_interrupt_variant", "(", "void", ")", "{", "return", "(", "interrupt_handler", "||", "fast_interrupt", ")", ";", "}", "</s>" ]

[ "Return", "whether", "function", "is", "tagged", "with", "'interrupt_handler", "'", "or", "'fast_interrupt", "'", "attribute", ".", "Return", "true", "if", "function", "should", "use", "return", "from", "interrupt", "rather", "than", "normal", "function", "return", "." ]

[ "microblaze" ]

[]

[ "<s>", "static", "int", "find_r0_life_regions", "(", "basic_block", "b", ")", "{", "bool", "live", ";", "int", "set", ";", "int", "death", "=", "0", ";", "if", "(", "REGNO_REG_SET_P", "(", "df_get_live_in", "(", "b", ")", ",", "R0_REG", ")", ")", "{", "set", "=", "1", ";", "live", "=", "true", ";", "}", "else", "{", "set", "=", "0", ";", "live", "=", "false", ";", "}", "rtx_insn", "*", "insn", "=", "BB_HEAD", "(", "b", ")", ";", "rtx_insn", "*", "end", "=", "BB_END", "(", "b", ")", ";", "rtx", "r0_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "R0_REG", ")", ";", "while", "(", "1", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "R0_REG", ")", ")", "{", "death", "++", ";", "live", "=", "false", ";", "}", "rtx", "pset", ";", "if", "(", "!", "live", "&&", "(", "pset", "=", "single_set", "(", "insn", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "r0_reg", ",", "SET_DEST", "(", "pset", ")", ")", "&&", "!", "find_regno_note", "(", "insn", ",", "REG_UNUSED", ",", "R0_REG", ")", ")", "{", "set", "++", ";", "live", "=", "true", ";", "}", "}", "if", "(", "insn", "==", "end", ")", "break", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "return", "set", "-", "death", ";", "}", "</s>" ]

[ "Count", "life", "regions", "of", "r0", "for", "a", "block", "." ]

[ "sh", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "void", "rs6000_split_logical_inner", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "rtx", "bool_rtx", ";", "if", "(", "op2", "&&", "GET_CODE", "(", "op2", ")", "==", "CONST_INT", "&&", "(", "mode", "==", "SImode", "||", "(", "mode", "==", "DImode", "&&", "TARGET_POWERPC64", ")", ")", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "mode", ")", ";", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2", ")", "&", "mask", ";", "if", "(", "code", "==", "AND", ")", "{", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "else", "if", "(", "value", "==", "mask", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "code", "==", "IOR", "||", "code", "==", "XOR", ")", "{", "if", "(", "value", "==", "0", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "}", "if", "(", "code", "==", "AND", "&&", "mode", "==", "SImode", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "dest", ",", "op1", ",", "op2", ")", ")", ";", "return", ";", "}", "if", "(", "complement_op1_p", ")", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "if", "(", "complement_op2_p", ")", "op2", "=", "gen_rtx_NOT", "(", "mode", ",", "op2", ")", ";", "if", "(", "!", "complement_op1_p", "&&", "complement_op2_p", ")", "std", "::", "swap", "(", "op1", ",", "op2", ")", ";", "bool_rtx", "=", "(", "(", "code", "==", "NOT", ")", "?", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ":", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op1", ",", "op2", ")", ")", ";", "if", "(", "complement_final_p", ")", "bool_rtx", "=", "gen_rtx_NOT", "(", "mode", ",", "bool_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "bool_rtx", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_split_logical", "to", "emit", "a", "logical", "instruction", "after", "spliting", "the", "operation", "to", "single", "GPR", "registers", ".", "DEST", "is", "the", "destination", "register", ".", "OP1", "and", "OP2", "are", "the", "input", "source", "registers", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "MODE", "is", "the", "machine", "mode", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", "." ]

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

[]

[ "<s>", "static", "RegDomain", "getDomain", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "{", "if", "(", "isGPR", "(", "RC", ")", ")", "return", "GPRDomain", ";", "if", "(", "isMask", "(", "RC", ",", "TRI", ")", ")", "return", "MaskDomain", ";", "return", "OtherDomain", ";", "}", "</s>" ]

[ "Get", "the", "MDNode", "for", "this", "AliasScopeNode", "'s", "domain", "." ]

[ "X86" ]

[]

[ "<s>", "int", "pdp11_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "get_frame_size", "(", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "return", "pdp11_reg_save_size", "(", ")", "+", "2", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "pdp11_reg_save_size", "(", ")", "+", "2", "+", "get_frame_size", "(", ")", ";", "else", "gcc_assert", "(", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "pdp11", "2", "2", "0" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"only integer returns supported\"", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::OutputArg", "BPFISD::RET_FLAG", "16", "\"only integer returns supported\"", "MVT::Other", "BPF", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "MVT::Other" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "if", "(", "Kind", "==", "k_RegisterIndex", "&&", "RegIdx", ".", "Index", "==", "0", "&&", "RegIdx", ".", "Kind", "&", "RegKind_GPR", ")", "return", "getGPR32Reg", "(", ")", ";", "assert", "(", "Kind", "==", "k_PhysRegister", "&&", "\"Invalid access!\"", ")", ";", "return", "PhysReg", ".", "Num", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Mips", "0", "\"Invalid access!\"" ]

[]

[ "<s>", "void", "GCNMaxOccupancySchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "DAG", ")", "{", "GenericScheduler", "::", "initialize", "(", "DAG", ")", ";", "const", "SIRegisterInfo", "*", "SRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "TRI", ")", ";", "const", "int", "ErrorMargin", "=", "3", ";", "SGPRExcessLimit", "=", "Context", "->", "RegClassInfo", "->", "getNumAllocatableRegs", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", "-", "ErrorMargin", ";", "VGPRExcessLimit", "=", "Context", "->", "RegClassInfo", "->", "getNumAllocatableRegs", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", "-", "ErrorMargin", ";", "SGPRCriticalLimit", "=", "SRI", "->", "getRegPressureSetLimit", "(", "DAG", "->", "MF", ",", "SRI", "->", "getSGPRPressureSet", "(", ")", ")", "-", "ErrorMargin", ";", "VGPRCriticalLimit", "=", "SRI", "->", "getRegPressureSetLimit", "(", "DAG", "->", "MF", ",", "SRI", "->", "getVGPRPressureSet", "(", ")", ")", "-", "ErrorMargin", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "3", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "void", "SparcPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSparcDelaySlotFillerPass", "(", ")", ")", ";", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "insertNOPLoad", "(", ")", ")", "{", "addPass", "(", "new", "InsertNOPLoad", "(", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "detectRoundChange", "(", ")", ")", "{", "addPass", "(", "new", "DetectRoundChange", "(", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "fixAllFDIVSQRT", "(", ")", ")", "{", "addPass", "(", "new", "FixAllFDIVSQRT", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "Op", ".", "getImm", "(", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "EvaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "\"0x\"", ";", "O", ".", "write_hex", "(", "Address", ")", ";", "}", "else", "{", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "\"unknown pcrel immediate operand\"", "\"0x\"" ]

[]

[ "<s>", "static", "bool", "c4x_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "HOST_WIDE_INT", "val", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "val", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "c4x_J_constant", "(", "x", ")", ")", "*", "total", "=", "0", ";", "else", "if", "(", "!", "TARGET_C3X", "&&", "outer_code", "==", "AND", "&&", "(", "val", "==", "255", "||", "val", "==", "65535", ")", ")", "*", "total", "=", "0", ";", "else", "if", "(", "!", "TARGET_C3X", "&&", "(", "outer_code", "==", "ASHIFTRT", "||", "outer_code", "==", "LSHIFTRT", ")", "&&", "(", "val", "==", "16", "||", "val", "==", "24", ")", ")", "*", "total", "=", "0", ";", "else", "if", "(", "TARGET_C3X", "&&", "SHIFT_CODE_P", "(", "outer_code", ")", ")", "*", "total", "=", "3", ";", "else", "if", "(", "LOGICAL_CODE_P", "(", "outer_code", ")", "?", "c4x_L_constant", "(", "x", ")", ":", "c4x_I_constant", "(", "x", ")", ")", "*", "total", "=", "2", ";", "else", "*", "total", "=", "4", ";", "return", "true", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "4", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "c4x_H_constant", "(", "x", ")", ")", "*", "total", "=", "2", ";", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "QFmode", ")", "*", "total", "=", "4", ";", "else", "*", "total", "=", "8", ";", "return", "true", ";", "case", "PLUS", ":", "case", "MINUS", ":", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "case", "MULT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", "||", "TARGET_MPYI", "?", "1", ":", "14", ")", ";", "return", "true", ";", "case", "DIV", ":", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", "?", "15", ":", "50", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "c4x", "0", "255", "65535", "0", "16", "24", "0", "3", "2", "4", "4", "2", "4", "8", "1", "1", "14", "15", "50" ]

[]

[ "<s>", "SDValue", "HexagonSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "AlwaysInline", "||", "(", "Align", "&", "0x3", ")", "!=", "0", "||", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "SizeVal", "=", "ConstantSize", "->", "getZExtValue", "(", ")", ";", "if", "(", "SizeVal", "<", "32", "||", "(", "SizeVal", "%", "8", ")", "!=", "0", ")", "return", "SDValue", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "SpecialMemcpyName", "=", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getTargetExternalSymbol", "(", "SpecialMemcpyName", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0x3", "0", "32", "8", "0", "\"__hexagon_memcpy_likely_aligned_min32bytes_mult8bytes\"", "0" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"Shrink-wrapping not yet supported\"", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FP", "MSP430::MOV16rr", "MSP430::FP", "MSP430::SP", "MSP430::FP", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "static", "void", "arm_emit_vfp_multi_reg_pop", "(", "int", "first_reg", ",", "int", "num_regs", ",", "rtx", "base_reg", ")", "{", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "tmp", ",", "reg", ";", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "32", ")", ";", "if", "(", "num_regs", "==", "2", "&&", "!", "arm_arch6", ")", "{", "if", "(", "first_reg", "==", "15", ")", "first_reg", "--", ";", "num_regs", "++", ";", "}", "if", "(", "num_regs", ">", "16", ")", "{", "arm_emit_vfp_multi_reg_pop", "(", "first_reg", ",", "16", ",", "base_reg", ")", ";", "arm_emit_vfp_multi_reg_pop", "(", "first_reg", "+", "16", ",", "num_regs", "-", "16", ",", "base_reg", ")", ";", "return", ";", "}", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "1", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "base_reg", ",", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "8", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "tmp", ";", "for", "(", "j", "=", "0", ",", "i", "=", "first_reg", ";", "j", "<", "num_regs", ";", "i", "+=", "2", ")", "{", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "i", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "gen_frame_mem", "(", "DFmode", ",", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "8", "*", "j", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "+", "1", ")", "=", "tmp", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "j", "++", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "dwarf", ";", "if", "(", "TARGET_VFP", "&&", "REGNO", "(", "base_reg", ")", "==", "IP_REGNUM", ")", "{", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "add_reg_note", "(", "par", ",", "REG_CFA_DEF_CFA", ",", "hard_frame_pointer_rtx", ")", ";", "}", "else", "arm_add_cfa_adjust_cfa_note", "(", "par", ",", "2", "*", "UNITS_PER_WORD", "*", "num_regs", ",", "base_reg", ",", "base_reg", ")", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "pattern", "that", "we", "will", "recognize", "as", "a", "pop_multi", "of", "NUM_REGS", "consecutive", "VFP", "regs", ",", "starting", "at", "FIRST_REG", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

[ "arm", "32", "2", "15", "16", "16", "16", "16", "1", "8", "1", "0", "0", "0", "2", "8", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", ";", "if", "(", "isPPC64", ")", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "else", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".got2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "MapVector", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "I", "->", "first", ";", "if", "(", "isPPC64", ")", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "else", "OutStreamer", ".", "EmitSymbolValue", "(", "S", ",", "4", ")", ";", "}", "}", "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "\".got2\"", "PPC", "4", "0", "PPC", "8", "4" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "Register", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", "->", "get", "(", "AArch64", "::", "ADDXri", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", "->", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "unsigned", "Shifter", "=", "AArch64_AM", "::", "getShifterImm", "(", "AArch64_AM", "::", "LSL", ",", "0", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ".", "addImm", "(", "Shifter", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::ADDXri", "0", "AArch64_AM::getShifterImm", "AArch64_AM::LSL", "0" ]

[]

[ "<s>", "static", "unsigned", "getBit", "(", "InsnType", "insn", ",", "int", "pos", ")", "{", "return", "getBits", "(", "insn", ",", "pos", ",", "1", ")", ";", "}", "</s>" ]

[ "Get", "the", "Init", "value", "of", "the", "specified", "bit", "." ]

[ "AArch64", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Hardware Loop Fixup\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Hardware Loop Fixup\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "if", "(", "isALU", "(", "*", "I", ")", ")", "I", "=", "MakeALUClause", "(", "MBB", ",", "I", ")", ";", "else", "++", "I", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "AMDGPU::CF_ALU" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "case", "SP", "::", "SELECT_CC_QFP_ICC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "BCOND", ")", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "case", "SP", "::", "SELECT_CC_QFP_FCC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "FBCOND", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_ADD_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ADDrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_ADD_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ADDXrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_SUB_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "SUBrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_SUB_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "SUBXrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_AND_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ANDrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_AND_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ANDXrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_OR_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ORrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_OR_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ORXrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_XOR_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "XORrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_XOR_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "XORXrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_NAND_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ANDrr", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_NAND_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "ANDXrr", ")", ";", "case", "SP", "::", "ATOMIC_SWAP_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "0", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_MAX_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVICCrr", ",", "SPCC", "::", "ICC_G", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_MAX_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVXCCrr", ",", "SPCC", "::", "ICC_G", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_MIN_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVICCrr", ",", "SPCC", "::", "ICC_LE", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_MIN_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVXCCrr", ",", "SPCC", "::", "ICC_LE", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_UMAX_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVICCrr", ",", "SPCC", "::", "ICC_GU", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_UMAX_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVXCCrr", ",", "SPCC", "::", "ICC_GU", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_UMIN_32", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVICCrr", ",", "SPCC", "::", "ICC_LEU", ")", ";", "case", "SP", "::", "ATOMIC_LOAD_UMIN_64", ":", "return", "expandAtomicRMW", "(", "MI", ",", "BB", ",", "SP", "::", "MOVXCCrr", ",", "SPCC", "::", "ICC_LEU", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::SELECT_CC_QFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::SELECT_CC_QFP_FCC", "SP::FBCOND", "SP::ATOMIC_LOAD_ADD_32", "SP::ADDrr", "SP::ATOMIC_LOAD_ADD_64", "SP::ADDXrr", "SP::ATOMIC_LOAD_SUB_32", "SP::SUBrr", "SP::ATOMIC_LOAD_SUB_64", "SP::SUBXrr", "SP::ATOMIC_LOAD_AND_32", "SP::ANDrr", "SP::ATOMIC_LOAD_AND_64", "SP::ANDXrr", "SP::ATOMIC_LOAD_OR_32", "SP::ORrr", "SP::ATOMIC_LOAD_OR_64", "SP::ORXrr", "SP::ATOMIC_LOAD_XOR_32", "SP::XORrr", "SP::ATOMIC_LOAD_XOR_64", "SP::XORXrr", "SP::ATOMIC_LOAD_NAND_32", "SP::ANDrr", "SP::ATOMIC_LOAD_NAND_64", "SP::ANDXrr", "SP::ATOMIC_SWAP_64", "0", "SP::ATOMIC_LOAD_MAX_32", "SP::MOVICCrr", "SPCC::ICC_G", "SP::ATOMIC_LOAD_MAX_64", "SP::MOVXCCrr", "SPCC::ICC_G", "SP::ATOMIC_LOAD_MIN_32", "SP::MOVICCrr", "SPCC::ICC_LE", "SP::ATOMIC_LOAD_MIN_64", "SP::MOVXCCrr", "SPCC::ICC_LE", "SP::ATOMIC_LOAD_UMAX_32", "SP::MOVICCrr", "SPCC::ICC_GU", "SP::ATOMIC_LOAD_UMAX_64", "SP::MOVXCCrr", "SPCC::ICC_GU", "SP::ATOMIC_LOAD_UMIN_32", "SP::MOVICCrr", "SPCC::ICC_LEU", "SP::ATOMIC_LOAD_UMIN_64", "SP::MOVXCCrr", "SPCC::ICC_LEU" ]

[]

[ "<s>", "static", "void", "mips_output_32bit_xfer", "(", "char", "direction", ",", "unsigned", "int", "gpreg", ",", "unsigned", "int", "fpreg", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tm%cc1\\t%s,%s\\n\"", ",", "direction", ",", "reg_names", "[", "gpreg", "]", ",", "reg_names", "[", "fpreg", "]", ")", ";", "}", "</s>" ]

[ "Write", "instructions", "to", "move", "a", "32-bit", "value", "between", "general", "register", "GPREG", "and", "floating-point", "register", "FPREG", ".", "DIRECTION", "is", "'t", "'", "to", "move", "from", "GPREG", "to", "FPREG", "and", "'", "f", "'", "to", "move", "in", "the", "opposite", "direction", "." ]

[ "mips", "\"\\tm%cc1\\t%s,%s\\n\"" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "RISCVInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "ADDI", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "case", "RISCV", "::", "FSGNJ_D", ":", "case", "RISCV", "::", "FSGNJ_S", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "RISCV", "RISCV", "0", "1", "RISCV::ADDI", "1", "2", "2", "0", "0", "1", "RISCV::FSGNJ_D", "RISCV::FSGNJ_S", "1", "2", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "MOSNoRecurse", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**** MOS NoRecurse Pass ****\\n\"", ")", ";", "CallGraph", "&", "CG", "=", "getAnalysis", "<", "CallGraphWrapperPass", ">", "(", ")", ".", "getCallGraph", "(", ")", ";", "assert", "(", "CG", ".", "getCallsExternalNode", "(", ")", "->", "empty", "(", ")", ")", ";", "CG", ".", "getCallsExternalNode", "(", ")", "->", "addCalledFunction", "(", "nullptr", ",", "CG", ".", "getExternalCallingNode", "(", ")", ")", ";", "scc_iterator", "<", "CallGraph", "*", ">", "CGI", "=", "scc_begin", "(", "&", "CG", ")", ";", "CallGraphSCC", "CurSCC", "(", "CG", ",", "&", "CGI", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", ";", "!", "CGI", ".", "isAtEnd", "(", ")", ";", "++", "CGI", ")", "{", "CurSCC", ".", "initialize", "(", "*", "CGI", ")", ";", "Changed", "|=", "runOnSCC", "(", "CurSCC", ")", ";", "}", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "HasInterrupts", "=", "true", ";", "markReachableFromMultipleInterrupts", "(", "*", "CG", "[", "&", "F", "]", ")", ";", "}", "}", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"interrupt-norecurse\"", ")", "||", "F", ".", "getName", "(", ")", "==", "\"main\"", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"interrupt-norecurse\"", ")", ")", "HasInterrupts", "=", "true", ";", "visitNorecurseInterrupt", "(", "*", "CG", "[", "&", "F", "]", ")", ";", "for", "(", "const", "auto", "*", "CGN", ":", "ReachableFromCurrentNorecurseInterrupt", ")", "ReachableFromOtherNorecurseInterrupt", ".", "insert", "(", "CGN", ")", ";", "ReachableFromCurrentNorecurseInterrupt", ".", "clear", "(", ")", ";", "}", "}", "if", "(", "HasInterrupts", ")", "{", "Changed", "=", "true", ";", "for", "(", "const", "char", "*", "LibcallName", ":", "lto", "::", "LTO", "::", "getRuntimeLibcallSymbols", "(", ")", ")", "{", "Function", "*", "Libcall", "=", "M", ".", "getFunction", "(", "LibcallName", ")", ";", "if", "(", "Libcall", "&&", "!", "Libcall", "->", "isDeclaration", "(", ")", "&&", "Libcall", "->", "doesNotRecurse", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Marking libcall as possibly recursive: \"", "<<", "Libcall", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "Libcall", "->", "removeFnAttr", "(", "Attribute", "::", "NoRecurse", ")", ";", "}", "}", "}", "CG", ".", "getCallsExternalNode", "(", ")", "->", "removeAllCalledFunctions", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "\"**** MOS NoRecurse Pass ****\\n\"", "\"interrupt\"", "\"interrupt-norecurse\"", "\"main\"", "\"interrupt-norecurse\"", "\"Marking libcall as possibly recursive: \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "assert", "(", "Pred1", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC first predicate\"", ")", ";", "assert", "(", "Pred2", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC second predicate\"", ")", ";", "if", "(", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "if", "(", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "if", "(", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "!=", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", ")", "return", "false", ";", "PPC", "::", "Predicate", "P1", "=", "(", "PPC", "::", "Predicate", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "PPC", "::", "Predicate", "P2", "=", "(", "PPC", "::", "Predicate", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "P1", "==", "P2", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_LE", "&&", "(", "P2", "==", "PPC", "::", "PRED_LT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_GE", "&&", "(", "P2", "==", "PPC", "::", "PRED_GT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "PowerPC", "PPC", "2", "\"Invalid PPC first predicate\"", "2", "\"Invalid PPC second predicate\"", "1", "PPC::CTR8", "1", "PPC::CTR", "1", "PPC::CTR8", "1", "PPC::CTR", "1", "1", "PPC::Predicate", "PPC::Predicate", "0", "PPC::Predicate", "PPC::Predicate", "0", "PPC::PRED_LE", "PPC::PRED_LT", "PPC::PRED_EQ", "PPC::PRED_GE", "PPC::PRED_GT", "PPC::PRED_EQ" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Retpoline Thunks\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Retpoline Thunks\"" ]

[]

[ "<s>", "const", "TPCRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "void", "AArch64TargetStreamer", "::", "emitCurrentConstantPool", "(", ")", "{", "ConstantPools", "->", "emitForCurrentSection", "(", "Streamer", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC_LO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC_HI", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR_LO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "FLAT_SCR_HI", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR255", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR254", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "hasSGPRInitBug", "(", ")", ")", "{", "unsigned", "NumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "Limit", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "4", ";", "for", "(", "unsigned", "i", "=", "Limit", ";", "i", "<", "NumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "MCRegAliasIterator", "R", "=", "MCRegAliasIterator", "(", "Reg", ",", "this", ",", "true", ")", ";", "for", "(", ";", "R", ".", "isValid", "(", ")", ";", "++", "R", ")", "Reserved", ".", "set", "(", "*", "R", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::FLAT_SCR", "AMDGPU::FLAT_SCR_LO", "AMDGPU::FLAT_SCR_HI", "AMDGPU::VGPR255", "AMDGPU::VGPR254", "AMDGPU", "AMDGPU::SGPR_32RegClass", "AMDGPU", "4", "AMDGPU::SGPR_32RegClass" ]

[]

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

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

[ "Sparc", "\"fixupNeedsRelaxation() unimplemented\"" ]

[]

[ "<s>", "const", "MipsInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "isRegister", "(", ")", "{", "return", "isRegister", "(", "getToken", "(", ")", ",", "peekToken", "(", ")", ")", ";", "}", "</s>" ]

[ "isRegister", "-", "Returns", "true", "if", "this", "is", "a", "normal", "register", "use/def", "slot", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "{", "if", "(", "Imm", "==", "255", "||", "Imm", "==", "65535", ")", "return", "0", ";", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ")", ")", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "Imm", ".", "isAllOnesValue", "(", ")", ")", "return", "0", ";", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "ARM", "ARM", "1", "0", "255", "65535", "0", "32", "1", "12", "0", "1", "8", "0", "0" ]

[]

[ "<s>", "bool", "aarch64_emit_approx_div", "(", "rtx", "quo", ",", "rtx", "num", ",", "rtx", "den", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "quo", ")", ";", "if", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "HFmode", ")", "return", "false", ";", "bool", "use_approx_division_p", "=", "(", "flag_mlow_precision_div", "||", "(", "aarch64_tune_params", ".", "approx_modes", "->", "division", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "flag_trapping_math", "||", "!", "flag_unsafe_math_optimizations", "||", "optimize_function_for_size_p", "(", "cfun", ")", "||", "!", "use_approx_division_p", ")", "return", "false", ";", "if", "(", "!", "TARGET_SIMD", "&&", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "rtx", "xrcp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_aarch64_frecpe", "(", "mode", ",", "xrcp", ",", "den", ")", ")", ";", "int", "iterations", "=", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "DFmode", ")", "?", "3", ":", "2", ";", "if", "(", "flag_mlow_precision_div", ")", "iterations", "--", ";", "rtx", "xtmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "while", "(", "iterations", "--", ")", "{", "emit_insn", "(", "gen_aarch64_frecps", "(", "mode", ",", "xtmp", ",", "xrcp", ",", "den", ")", ")", ";", "if", "(", "iterations", ">", "0", ")", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "}", "if", "(", "num", "!=", "CONST1_RTX", "(", "mode", ")", ")", "{", "rtx", "xnum", "=", "force_reg", "(", "mode", ",", "num", ")", ";", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xnum", ")", ")", ";", "}", "emit_set_insn", "(", "quo", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "the", "instruction", "sequence", "to", "compute", "the", "approximation", "for", "the", "division", "of", "NUM", "by", "DEN", "in", "QUO", "and", "return", "whether", "the", "sequence", "was", "emitted", "or", "not", "." ]

[ "aarch64", "3", "2", "0" ]

[]

[ "<s>", "bool", "AAPInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOpc", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOpc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid opcode\"", ")", ";", "case", "AAP", "::", "BRA", ":", "return", "AAP", "::", "isOff22", "(", "BrOffset", ")", ";", "case", "AAP", "::", "BEQ_", ":", "case", "AAP", "::", "BNE_", ":", "case", "AAP", "::", "BLTS_", ":", "case", "AAP", "::", "BLES_", ":", "case", "AAP", "::", "BLTU_", ":", "case", "AAP", "::", "BLEU_", ":", "return", "AAP", "::", "isOff10", "(", "BrOffset", ")", ";", "}", "}", "</s>" ]

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

[ "AAP", "AAP", "\"Invalid opcode\"", "AAP::BRA", "AAP::isOff22", "AAP::BEQ_", "AAP::BNE_", "AAP::BLTS_", "AAP::BLES_", "AAP::BLTU_", "AAP::BLEU_", "AAP::isOff10" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "unsigned", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "R600Operands", "::", "WRITE", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", ")", ";", "setImmOperand", "(", "Mov", ",", "R600Operands", "::", "DST_REL", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

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

[ "R600", "R600Operands::WRITE", "0", "R600Operands::DST_REL", "1" ]

[]

[ "<s>", "bool", "loongarch_eh_uses", "(", "unsigned", "int", "regno", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Implement", "EH_USES", "." ]

[ "loongarch" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "NonScalarIntSafe", ",", "bool", "MemcpyStrSrc", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "this", "->", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "else", "{", "return", "MVT", "::", "i32", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "SystemZXPLINKFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "SIStackID", "::", "SGPR_SPILL", ")", ";", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "SIStackID::SGPR_SPILL", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "bool", "SVEIntrinsicOpts", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "false", ";", "SmallSetVector", "<", "Function", "*", ",", "4", ">", "Functions", ";", "for", "(", "auto", "&", "F", ":", "M", ".", "getFunctionList", "(", ")", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "switch", "(", "F", ".", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "experimental_vector_extract", ":", "case", "Intrinsic", "::", "experimental_vector_insert", ":", "case", "Intrinsic", "::", "aarch64_sve_ptrue", ":", "for", "(", "User", "*", "U", ":", "F", ".", "users", "(", ")", ")", "Functions", ".", "insert", "(", "cast", "<", "Instruction", ">", "(", "U", ")", "->", "getFunction", "(", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "!", "Functions", ".", "empty", "(", ")", ")", "Changed", "|=", "optimizeFunctions", "(", "Functions", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "4", "Intrinsic::experimental_vector_extract", "Intrinsic::experimental_vector_insert", "Intrinsic::aarch64_sve_ptrue" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_reg_using_mov", "(", "machine_mode", "mode", ",", "unsigned", "int", "regno", ",", "HOST_WIDE_INT", "cfa_offset", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rtx", "unspec", "=", "NULL_RTX", ";", "rtx", "mem", ",", "addr", ",", "base", ",", "insn", ";", "unsigned", "int", "align", ";", "addr", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "INCOMING_STACK_BOUNDARY", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "if", "(", "mode", "==", "V4SFmode", "&&", "align", "<", "128", ")", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_STOREU", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "unspec", "?", "unspec", ":", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "base", "=", "addr", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "gcc_checking_assert", "(", "REG_P", "(", "base", ")", ")", ";", "if", "(", "m", "->", "fs", ".", "realigned", ")", "{", "gcc_checking_assert", "(", "stack_realign_drap", ")", ";", "if", "(", "regno", "==", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "mem", ")", ";", "}", "else", "{", "gcc_checking_assert", "(", "cfun", "->", "machine", "->", "fs", ".", "fp_valid", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "cfun", "->", "machine", "->", "fs", ".", "fp_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "else", "if", "(", "base", "!=", "m", "->", "fs", ".", "cfa_reg", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "m", "->", "fs", ".", "cfa_reg", ",", "m", "->", "fs", ".", "cfa_offset", "-", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "else", "if", "(", "unspec", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_EXPRESSION", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "single", "register", "save", "at", "CFA", "-", "CFA_OFFSET", "." ]

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

[]

[ "<s>", "static", "int", "riscv_extend_cost", "(", "rtx", "op", ",", "bool", "unsigned_p", ")", "{", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "0", ";", "if", "(", "unsigned_p", "&&", "GET_MODE", "(", "op", ")", "==", "QImode", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "TARGET_ZBA", "&&", "TARGET_64BIT", "&&", "unsigned_p", "&&", "GET_MODE", "(", "op", ")", "==", "SImode", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "TARGET_ZBB", ")", "{", "if", "(", "!", "unsigned_p", "&&", "GET_MODE", "(", "op", ")", "==", "QImode", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "HImode", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "!", "unsigned_p", "&&", "GET_MODE", "(", "op", ")", "==", "SImode", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "sign-", "or", "zero-extending", "OP", "." ]

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

[]

[ "<s>", "rtx", "aarch64_simd_gen_const_vector_dup", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "rtx", "c", "=", "gen_int_mode", "(", "val", ",", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "return", "gen_const_vec_duplicate", "(", "mode", ",", "c", ")", ";", "}", "</s>" ]

[ "Return", "a", "const_int", "vector", "of", "VAL", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "rl78_alloc_physical_registers_umul", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "prev", "=", "prev_nonnote_nondebug_insn", "(", "insn", ")", ";", "rtx", "first", ";", "int", "tmp_id", ";", "rtx", "saved_op1", ";", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "BC", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "DE", ",", "insn", ")", ";", "OP", "(", "2", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "2", ")", ",", "HL", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "recog_data", ".", "constraints", "[", "1", "]", "[", "0", "]", "==", "'%'", "&&", "is_virtual_register", "(", "OP", "(", "1", ")", ")", "&&", "!", "is_virtual_register", "(", "OP", "(", "2", ")", ")", "&&", "!", "CONSTANT_P", "(", "OP", "(", "2", ")", ")", ")", "{", "rtx", "tmp", "=", "OP", "(", "1", ")", ";", "OP", "(", "1", ")", "=", "OP", "(", "2", ")", ";", "OP", "(", "2", ")", "=", "tmp", ";", "}", "OP", "(", "0", ")", "=", "move_from_acc", "(", "0", ",", "insn", ")", ";", "tmp_id", "=", "get_max_insn_count", "(", ")", ";", "saved_op1", "=", "OP", "(", "1", ")", ";", "if", "(", "rtx_equal_p", "(", "OP", "(", "1", ")", ",", "OP", "(", "2", ")", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "OP", "(", "2", ")", ")", "==", "QImode", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "A", ";", "}", "else", "OP", "(", "1", ")", "=", "move_to_acc", "(", "1", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "tmp_id", "==", "get_max_insn_count", "(", ")", ")", "force_into_acc", "(", "saved_op1", ",", "insn", ")", ";", "if", "(", "prev", ")", "first", "=", "next_nonnote_nondebug_insn", "(", "prev", ")", ";", "else", "for", "(", "first", "=", "insn", ";", "prev_nonnote_nondebug_insn", "(", "first", ")", ";", "first", "=", "prev_nonnote_nondebug_insn", "(", "first", ")", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "first", ")", ";", "MUST_BE_OK", "(", "insn", ")", ";", "}", "</s>" ]

[ "Like", "op2", ",", "but", "AX", "=", "A", "*", "X", "." ]

[ "rl78", "0", "0", "1", "1", "2", "2", "1", "0", "1", "2", "2", "1", "1", "2", "2", "0", "0", "1", "1", "2", "2", "2", "2", "1", "1", "1", "2", "2" ]

[]

[ "<s>", "inline", "bool", "wrapped_symbol_hasher", "::", "equal", "(", "const", "value_type", "*", "x", ",", "const", "compare_type", "*", "y", ")", "{", "return", "!", "strcmp", "(", "x", ",", "y", ")", ";", "}", "</s>" ]

[ "Compare", "H1", "and", "H2", "for", "equivalence", "." ]

[ "i386" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mips Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Delay Slot Filler\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "LC2200" ]

[]

[ "<s>", "bool", "AArch64PagerandoOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "isPagerando", "(", ")", "||", "skipFunction", "(", "F", ")", ")", "{", "return", "false", ";", "}", "auto", "BinPrefix", "=", "F", ".", "getSectionPrefix", "(", ")", ".", "getValue", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Worklist", ";", "for", "(", "auto", "&", "BB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "BB", ")", "{", "if", "(", "isIntraBin", "(", "MI", ",", "BinPrefix", ")", ")", "Worklist", ".", "push_back", "(", "&", "MI", ")", ";", "}", "}", "for", "(", "auto", "*", "MI", ":", "Worklist", ")", "optimizeCalls", "(", "MI", ")", ";", "return", "!", "Worklist", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]