File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/include/clang/Basic

usr / src / contrib / llvm-project / clang / include / clang / Basic /

📁 ..
📄 AArch64SVEACLETypes.def(7.09 KB)
📄 ABI.h(5.95 KB)
📄 ASTNode.td(120 B)
📄 AddressSpaces.h(2.59 KB)
📄 AlignedAllocation.h(1.38 KB)
📄 AllDiagnostics.h(1.44 KB)
📄 Attr.td(122.78 KB)
📄 AttrDocs.td(197.8 KB)
📄 AttrKinds.h(929 B)
📄 AttrSubjectMatchRules.h(957 B)
📄 AttributeCommonInfo.h(7.02 KB)
📄 Attributes.h(1.35 KB)
📄 BitmaskEnum.h(749 B)
📄 Builtins.def(71.64 KB)
📄 Builtins.h(9.13 KB)
📄 BuiltinsAArch64.def(14.31 KB)
📄 BuiltinsAMDGPU.def(13.1 KB)
📄 BuiltinsARM.def(18.6 KB)
📄 BuiltinsBPF.def(1016 B)
📄 BuiltinsHexagon.def(6.15 KB)
📄 BuiltinsHexagonDep.def(117.26 KB)
📄 BuiltinsHexagonMapCustomDep.def(8.56 KB)
📄 BuiltinsLe64.def(728 B)
📄 BuiltinsMips.def(35.51 KB)
📄 BuiltinsNEON.def(814 B)
📄 BuiltinsNVPTX.def(27.63 KB)
📄 BuiltinsPPC.def(21.53 KB)
📄 BuiltinsSVE.def(786 B)
📄 BuiltinsSystemZ.def(19.7 KB)
📄 BuiltinsWebAssembly.def(10.17 KB)
📄 BuiltinsX86.def(140.49 KB)
📄 BuiltinsX86_64.def(6.79 KB)
📄 BuiltinsXCore.def(846 B)
📄 CapturedStmt.h(662 B)
📄 CharInfo.h(6.52 KB)
📄 CodeGenOptions.def(21.65 KB)
📄 CodeGenOptions.h(14.14 KB)
📄 CommentNodes.td(1.04 KB)
📄 CommentOptions.h(1.1 KB)
📄 Cuda.h(2.3 KB)
📄 DebugInfoOptions.h(1.72 KB)
📄 DeclNodes.td(4.72 KB)
📄 Diagnostic.h(55.73 KB)
📄 Diagnostic.td(5.29 KB)
📄 DiagnosticAST.h(903 B)
📄 DiagnosticASTKinds.td(29.35 KB)
📄 DiagnosticAnalysis.h(933 B)
📄 DiagnosticAnalysisKinds.td(405 B)
📄 DiagnosticCategories.h(757 B)
📄 DiagnosticCategories.td(480 B)
📄 DiagnosticComment.h(927 B)
📄 DiagnosticCommentKinds.td(6.18 KB)
📄 DiagnosticCommonKinds.td(14.32 KB)
📄 DiagnosticCrossTU.h(927 B)
📄 DiagnosticCrossTUKinds.td(889 B)
📄 DiagnosticDocs.td(1.96 KB)
📄 DiagnosticDriver.h(921 B)
📄 DiagnosticDriverKinds.td(25.54 KB)
📄 DiagnosticError.h(1.98 KB)
📄 DiagnosticFrontend.h(933 B)
📄 DiagnosticFrontendKinds.td(13.86 KB)
📄 DiagnosticGroups.td(59.71 KB)
📄 DiagnosticIDs.h(12.83 KB)
📄 DiagnosticLex.h(903 B)
📄 DiagnosticLexKinds.td(38.36 KB)
📄 DiagnosticOptions.def(4.58 KB)
📄 DiagnosticOptions.h(4.21 KB)
📄 DiagnosticParse.h(915 B)
📄 DiagnosticParseKinds.td(68.47 KB)
📄 DiagnosticRefactoring.h(951 B)
📄 DiagnosticRefactoringKinds.td(1.33 KB)
📄 DiagnosticSema.h(909 B)
📄 DiagnosticSemaKinds.td(546.17 KB)
📄 DiagnosticSerialization.h(962 B)
📄 DiagnosticSerializationKinds.td(18.08 KB)
📄 ExceptionSpecificationType.h(2.48 KB)
📄 ExpressionTraits.h(1.18 KB)
📄 FPOptions.def(1.16 KB)
📄 Features.def(11.55 KB)
📄 FileManager.h(16.39 KB)
📄 FileSystemOptions.h(924 B)
📄 FileSystemStatCache.h(3.26 KB)
📄 FixedPoint.h(8.6 KB)
📄 IdentifierTable.h(33.75 KB)
📄 JsonSupport.h(3.69 KB)
📄 LLVM.h(2.43 KB)
📄 Lambda.h(1.37 KB)
📄 LangOptions.def(21.96 KB)
📄 LangOptions.h(18.78 KB)
📄 LangStandard.h(3.87 KB)
📄 LangStandards.def(6.8 KB)
📄 Linkage.h(4.13 KB)
📄 MSP430Target.def(7.04 KB)
📄 MacroBuilder.h(1.34 KB)
📄 Module.h(24.09 KB)
📄 ObjCRuntime.h(14.36 KB)
📄 OpenCLExtensionTypes.def(1.59 KB)
📄 OpenCLExtensions.def(4.38 KB)
📄 OpenCLImageTypes.def(4.1 KB)
📄 OpenCLOptions.h(4.42 KB)
📄 OpenMPKinds.def(4.58 KB)
📄 OpenMPKinds.h(9.66 KB)
📄 OperatorKinds.def(6.56 KB)
📄 OperatorKinds.h(1.55 KB)
📄 OperatorPrecedence.h(1.82 KB)
📄 PartialDiagnostic.h(12.96 KB)
📄 PlistSupport.h(4.02 KB)
📄 PragmaKinds.h(1.21 KB)
📄 PrettyStackTrace.h(1.26 KB)
📄 SanitizerBlacklist.h(1.73 KB)
📄 SanitizerSpecialCaseList.h(1.81 KB)
📄 Sanitizers.def(6.41 KB)
📄 Sanitizers.h(6.57 KB)
📄 SourceLocation.h(15.56 KB)
📄 SourceManager.h(71.11 KB)
📄 SourceManagerInternals.h(4.27 KB)
📄 Specifiers.h(12.68 KB)
📄 Stack.h(1.94 KB)
📄 StmtNodes.td(10.92 KB)
📄 SyncScope.h(4.87 KB)
📄 TargetBuiltins.h(9.18 KB)
📄 TargetCXXABI.h(12.49 KB)
📄 TargetInfo.h(54.4 KB)
📄 TargetOptions.h(3 KB)
📄 TemplateKinds.h(2.22 KB)
📄 TokenKinds.def(33.83 KB)
📄 TokenKinds.h(3.99 KB)
📄 TypeNodes.td(5.48 KB)
📄 TypeTraits.h(2.67 KB)
📄 Version.h(2.23 KB)
📄 Visibility.h(4.4 KB)
📄 X86Target.def(5.21 KB)
📄 XRayInstr.h(1.92 KB)
📄 XRayLists.h(1.73 KB)
📄 arm_bf16.td(590 B)
📄 arm_cde.td(9.29 KB)
📄 arm_fp16.td(5.79 KB)
📄 arm_mve.td(70.85 KB)
📄 arm_mve_defs.td(24.52 KB)
📄 arm_neon.td(90.63 KB)
📄 arm_neon_incl.td(13.64 KB)
📄 arm_sve.td(162.48 KB)

Editing: arm_cde.td

//===--- arm_cde.td - ACLE intrinsic functions for CDE --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the set of ACLE-specified source-level intrinsic
// functions wrapping the CDE instructions.
//
//===----------------------------------------------------------------------===//

include "arm_mve_defs.td"

// f64 is not defined in arm_mve_defs.td because MVE instructions only work with
// f16 and f32
def f64: PrimitiveType<"f", 64>;

// Float<t> expects t to be a scalar type, and expands to the floating-point
// type of the same width.
class Float<Type t>: ComplexType<(CTO_CopyKind t, f32)>;
def FScalar: Float<Scalar>;

// ACLE CDE intrinsic
class CDEIntrinsic<Type ret, dag args, dag codegen>
  : Intrinsic<ret, args, codegen> {
  let builtinExtension = "cde";
}

// Immediate (in range [0, 2^numBits - 1])
class IB_ConstBits<int numBits> : IB_ConstRange<0, !add(!shl(1, numBits), -1)>;
// numBits-wide immediate of type u32
class CDEImmediateBits<int numBits> : Immediate<u32, IB_ConstBits<numBits>>;

// LLVM IR CDE intrinsic
class CDEIRInt<string name, list<Type> params = [], bit appendKind = 0>
      : IRIntBase<"arm_cde_" # name, params, appendKind>;

// Class for generating function macros in arm_cde.h:
// "#define <name>(<params>) <definition>"
class FunctionMacro<list<string> params_, string definition_> {
  list<string> params = params_;
  string definition = definition_;
}

// Coprocessor immediate
def imm_coproc : Immediate<sint, IB_ConstRange<0, 7>>;

// Immediate integer parameters
def imm_3b : CDEImmediateBits<3>;
def imm_4b : CDEImmediateBits<4>;
def imm_6b :  CDEImmediateBits<6>;
def imm_7b :  CDEImmediateBits<7>;
def imm_9b :  CDEImmediateBits<9>;
def imm_11b : CDEImmediateBits<11>;
def imm_12b : CDEImmediateBits<12>;
def imm_13b : CDEImmediateBits<13>;

// CX* instructions operating on GPRs
multiclass CDE_CX_m<dag argsImm, dag argsReg, dag cgArgs> {
  defvar cp = (args imm_coproc:$cp);
  let pnt = PNT_None, params = T.None in {
    def "" : CDEIntrinsic<u32, !con(cp, argsReg, argsImm),
                               !con((CDEIRInt<NAME> $cp), cgArgs, (? $imm))>;
    def a  : CDEIntrinsic<u32, !con(cp, (args u32:$acc), argsReg, argsImm),
                               !con((CDEIRInt<NAME # "a"> $cp, $acc),
                                    cgArgs, (? $imm))>;

def d :
      CDEIntrinsic<u64, !con(cp, argsReg, argsImm),
            (seq !con((CDEIRInt<NAME # "d"> $cp), cgArgs, (? $imm)):$pair,
                 (or (shl (u64 (xval $pair, 1)), (u64 32)),
                          (u64 (xval $pair, 0))))>;
    def da :
      CDEIntrinsic<u64, !con(cp, (args u64:$acc), argsReg, argsImm),
            (seq (u32 (lshr $acc, (u64 32))):$acc_hi,
                 (u32 $acc):$acc_lo,
                 !con((CDEIRInt<NAME # "da"> $cp, $acc_lo, $acc_hi), cgArgs,
                       (? $imm)):$pair,
                 (or (shl (u64 (xval $pair, 1)), (u64 32)),
                          (u64 (xval $pair, 0))))>;
  }
}

defm cx1 : CDE_CX_m<(args imm_13b:$imm), (args), (?)>;
defm cx2 : CDE_CX_m<(args imm_9b:$imm), (args u32:$n), (? $n)>;
defm cx3 : CDE_CX_m<(args imm_6b:$imm), (args u32:$n, u32:$m), (? $n, $m)>;

// VCX* instructions operating on VFP registers
multiclass CDE_VCXFP_m<dag argsImm, dag argsReg32, dag argsReg64, dag cgArgs> {
  defvar cp = (args imm_coproc:$cp);
  let pnt = PNT_None, params = [u32] in {
    def "" : CDEIntrinsic<u32, !con(cp, argsReg32, argsImm),
          (bitcast !con((CDEIRInt<NAME, [f32]> $cp), cgArgs, (? $imm)),
                   Scalar)>;
    def a  : CDEIntrinsic<u32, !con(cp, (args u32:$acc), argsReg32, argsImm),
          (bitcast !con((CDEIRInt<NAME # "a", [f32]> $cp,
                         (bitcast $acc, FScalar)), cgArgs, (? $imm)), Scalar)>;
  }
  let pnt = PNT_None, params = [u64] in {
    def d  : CDEIntrinsic<u64, !con(cp, argsReg64, argsImm),
          (bitcast !con((CDEIRInt<NAME, [f64]> $cp), cgArgs, (? $imm)),
                   Scalar)>;
    def da : CDEIntrinsic<u64, !con(cp, (args u64:$acc), argsReg64, argsImm),
          (bitcast !con((CDEIRInt<NAME # "a", [f64]> $cp,
                         (bitcast $acc, FScalar)), cgArgs, (? $imm)), Scalar)>;
  }
}

defm vcx1: CDE_VCXFP_m<(args imm_11b:$imm), (args), (args), (?)>;
defm vcx2: CDE_VCXFP_m<(args imm_6b:$imm), (args u32:$n), (args u64:$n),
                       (? (bitcast $n, FScalar))>;
defm vcx3: CDE_VCXFP_m<(args imm_3b:$imm),
                       (args u32:$n, u32:$m), (args u64:$n, u64:$m),
                       (? (bitcast $n, FScalar), (bitcast $m, FScalar))>;

// VCX* instructions operating on Q vector registers

def v16u8 : VecOf<u8>;

let pnt = PNT_None, params = [u8] in
def vcx1q : CDEIntrinsic<Vector, (args imm_coproc:$cp, imm_12b:$imm),
                         (CDEIRInt<"vcx1q"> $cp, $imm)>;

let pnt = PNT_Type, params = T.All, polymorphicOnly = 1 in {
  def vcx1qa :
    CDEIntrinsic<Vector, (args imm_coproc:$cp, Vector:$acc, imm_12b:$imm),
            (bitcast (CDEIRInt<"vcx1qa"> $cp, (bitcast $acc, v16u8), $imm),
                     Vector)>;

def vcx2q :
    CDEIntrinsic<Vector, (args imm_coproc:$cp, Vector:$n, imm_7b:$imm),
            (bitcast (CDEIRInt<"vcx2q"> $cp, (bitcast $n, VecOf<u8>), $imm),
                      Vector)>;
  def vcx2q_u8 :
    CDEIntrinsic<v16u8, (args imm_coproc:$cp, Vector:$n, imm_7b:$imm),
            (CDEIRInt<"vcx2q"> $cp, (bitcast $n, VecOf<u8>), $imm)>;

def vcx2qa_impl :
    CDEIntrinsic<Vector,
            (args imm_coproc:$cp, Vector:$acc, v16u8:$n, imm_7b:$imm),
            (bitcast (CDEIRInt<"vcx2qa"> $cp, (bitcast $acc, v16u8), $n, $imm),
                     Vector)>;

def vcx3q_impl :
    CDEIntrinsic<Vector,
            (args imm_coproc:$cp, Vector:$n, v16u8:$m, imm_4b:$imm),
            (bitcast (CDEIRInt<"vcx3q"> $cp, (bitcast $n, v16u8), $m, $imm),
                     Vector)>;
  def vcx3q_u8_impl :
    CDEIntrinsic<v16u8,
            (args imm_coproc:$cp, Vector:$n, v16u8:$m, imm_4b:$imm),
            (CDEIRInt<"vcx3q"> $cp, (bitcast $n, v16u8), $m, $imm)>;
  def vcx3qa_impl :
    CDEIntrinsic<Vector,
            (args imm_coproc:$cp, Vector:$acc, v16u8:$n, v16u8:$m, imm_4b:$imm),
            (bitcast (CDEIRInt<"vcx3qa"> $cp, (bitcast $acc, v16u8), $n, $m,
                                         $imm),
                     Vector)>;
}

// Reinterpret intrinsics required to implement __arm_vcx*q with 2 or 3
// polymorphic paramters.
let params = [/* no u8 */ s8, u16, s16, u32, s32, u64, s64, f16, f32],
    headerOnly = 1, polymorphicOnly = 1 in
def vreinterpretq_u8 :
    Intrinsic<v16u8, (args Vector:$x), (vreinterpret $x, v16u8)>;

// We need vreinterpretq_u8_u8 to avoid doing smart tricks in the macros
let params = [u8], polymorphicOnly = 1 in
def vreinterpretq_u8_cde :
    CDEIntrinsic<v16u8, (args Vector:$x), (id $x)>,
    NameOverride<"vreinterpretq_u8">;

def vcx2qa : FunctionMacro<
  ["cp", "acc", "n", "imm"],
  "__arm_vcx2qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), (imm))">;

def vcx3q : FunctionMacro<
  ["cp", "n", "m", "imm"],
  "__arm_vcx3q_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))">;
def vcx3q_u8 : FunctionMacro<
  ["cp", "n", "m", "imm"],
  "__arm_vcx3q_u8_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))">;
def vcx3qa : FunctionMacro<
  ["cp", "acc", "n", "m", "imm"],
  "__arm_vcx3qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), "
                     "__arm_vreinterpretq_u8(m), (imm))">;

class CDEIntrinsicMasked<string irname, dag argsReg, dag imm, dag cgArgs>
  : CDEIntrinsic<Vector,
      !con((args imm_coproc:$cp, Vector:$inactive_or_acc),
           argsReg, imm, (args Predicate:$pred)),
      !con((CDEIRInt<irname # "_predicated", [Vector,Predicate]>
            $cp, $inactive_or_acc), cgArgs, (? $imm, $pred))> {
  let params = T.All;
  let polymorphicOnly = 1;
}

def vcx1q_m : CDEIntrinsicMasked<"vcx1q", (args), (args imm_12b:$imm), (?)>;
def vcx1qa_m : CDEIntrinsicMasked<"vcx1qa", (args), (args imm_12b:$imm), (?)>;

multiclass VCXPredicated<dag argsReg, dag imm, dag cgArgs,
                         list<string> macroArgs, string macro> {
  def _m_impl : CDEIntrinsicMasked<NAME, argsReg, imm, cgArgs>;
  def a_m_impl : CDEIntrinsicMasked<NAME#"a", argsReg, imm, cgArgs>;

def _m: FunctionMacro<
    !listconcat(["cp", "inactive"], macroArgs, ["imm", "pred"]),
    "__arm_"#NAME#"_m_impl((cp), (inactive), "#macro#" (imm), (pred))">;
  def a_m: FunctionMacro<
    !listconcat(["cp", "acc"], macroArgs, ["imm", "pred"]),
    "__arm_"#NAME#"a_m_impl((cp), (acc), "#macro#" (imm), (pred))">;
}

defm vcx2q :
  VCXPredicated<(args v16u8:$n), (args imm_7b:$imm), (? $n), ["n"],
                "__arm_vreinterpretq_u8(n),">;
defm vcx3q :
  VCXPredicated<(args v16u8:$n, v16u8:$m), (args imm_4b:$imm), (? $n, $m),
                ["n", "m"], "__arm_vreinterpretq_u8(n), "
                            "__arm_vreinterpretq_u8(m),">;

// vreinterpretq intrinsics required by the ACLE CDE specification

foreach desttype = [/* no u8 */ s8, u16, s16, u32, s32, u64, s64, f16, f32] in {
  let params = [u8], headerOnly = 1, pnt = PNT_None in
  def "vreinterpretq_" # desttype : Intrinsic<
    VecOf<desttype>, (args Vector:$x), (vreinterpret $x, VecOf<desttype>)>;
}

003 File Manager

Editing: arm_cde.td

Upload File

Create Folder