libc/spec/spec.td

   1 class Type {}
   2
   3 class NamedType<string name> : Type {
   4   string Name = name;
   5 }
   6
   7 class Field<string name, Type type> {
   8   string Name = name;
   9   Type FieldType = type;
  10 }
  11
  12 // Class to describe concrete structs specified by a standard.
  13 class Struct<string name> : NamedType<name> {
  14   list<Field> Fields;
  15 }
  16
  17 class EnumNameValue<string name, string value = "__default_enum_value__"> {
  18   string Name = name;
  19   string Value = value;
  20 }
  21
  22 class Enum<string name, list<EnumNameValue> enumerations> : NamedType<name> {
  23   list<EnumNameValue> Enumerations = enumerations;
  24 }
  25
  26 class PtrType<Type type> : Type {
  27   Type PointeeType = type;
  28 }
  29
  30 class ConstType<Type type> : Type {
  31   Type UnqualifiedType = type;
  32 }
  33
  34 class RestrictedPtrType<Type type> : Type {
  35   Type PointeeType = type;
  36 }
  37
  38 // Builtin types.
  39 def VarArgType : NamedType<"...">;
  40 def VaListType : NamedType<"va_list">;
  41 def VoidType : NamedType<"void">;
  42 def IntType : NamedType<"int">;
  43 def UnsignedIntType : NamedType<"unsigned int">;
  44 def LongType : NamedType<"long">;
  45 def UnsignedLongType : NamedType<"unsigned long">;
  46 def LongLongType : NamedType<"long long">;
  47 def UnsignedLongLongType : NamedType<"unsigned long long">;
  48 def FloatType : NamedType<"float">;
  49 def DoubleType : NamedType<"double">;
  50 def LongDoubleType : NamedType<"long double">;
  51 def CharType : NamedType<"char">;
  52 def UnsignedCharType : NamedType<"unsigned char">;
  53 def UnsignedShortType : NamedType<"unsigned short">;
  54 def BoolType : NamedType<"bool">;
  55
  56 def Float16Type : NamedType<"_Float16">;
  57 def Float128Type : NamedType<"float128">;
  58
  59 // Common types
  60 def VoidPtr : PtrType<VoidType>;
  61 def VoidPtrPtr : PtrType<VoidPtr>;
  62 def RestrictedVoidPtrPtr : RestrictedPtrType<VoidPtr>;
  63 def ConstVoidPtr : ConstType<VoidPtr>;
  64
  65 def SizeTType : NamedType<"size_t">;
  66 def SizeTPtr : PtrType<SizeTType>;
  67 def RestrictedSizeTPtr : RestrictedPtrType<SizeTType>;
  68
  69 def Char8TType : NamedType<"char8_t">;
  70 def Char16TType : NamedType<"char16_t">;
  71 def Char32TType : NamedType<"char32_t">;
  72 def WCharType : NamedType<"wchar_t">;
  73 def WIntType : NamedType<"wint_t">;
  74
  75 def LongDoublePtr : PtrType<LongDoubleType>;
  76
  77 def IntMaxTType : NamedType<"intmax_t">;
  78 def UIntMaxTType : NamedType<"uintmax_t">;
  79
  80 def UInt16Type : NamedType<"uint16_t">;
  81 def UInt32Type : NamedType<"uint32_t">;
  82
  83 def OffTType : NamedType<"off_t">;
  84 def OffTPtr : PtrType<OffTType>;
  85 def SSizeTType : NamedType<"ssize_t">;
  86
  87 // _Noreturn is really not a type, but it is convenient to treat it as a type.
  88 def NoReturn : NamedType<"_Noreturn void">;
  89
  90 //types moved from stdc.td
  91 def VoidRestrictedPtr : RestrictedPtrType<VoidType>;
  92 def ConstVoidRestrictedPtr : ConstType<VoidRestrictedPtr>;
  93
  94 def CharPtr : PtrType<CharType>;
  95 def ConstCharPtr : ConstType<CharPtr>;
  96 def CharRestrictedPtr : RestrictedPtrType<CharType>;
  97 def CharRestrictedPtrPtr : RestrictedPtrType<CharPtr>;
  98 def ConstCharRestrictedPtr : ConstType<CharRestrictedPtr>;
  99 def ConstCharRestrictedPtrPtr : PtrType<ConstCharRestrictedPtr>;
 100
 101 def OnceFlagType : NamedType<"once_flag">;
 102 def OnceFlagTypePtr : PtrType<OnceFlagType>;
 103 // TODO(sivachandra): Remove this non-standard type when a formal
 104 // way to describe callable types is available.
 105 def CallOnceFuncType : NamedType<"__call_once_func_t">;
 106 def MtxTType : NamedType<"mtx_t">;
 107 def MtxTTypePtr : PtrType<MtxTType>;
 108 def CndTType : NamedType<"cnd_t">;
 109 def CndTTypePtr : PtrType<CndTType>;
 110 def ThrdStartTType : NamedType<"thrd_start_t">;
 111 def ThrdTType : NamedType<"thrd_t">;
 112 def ThrdTTypePtr : PtrType<ThrdTType>;
 113
 114 def IntPtr : PtrType<IntType>;
 115 def RestrictedIntPtr : RestrictedPtrType<IntType>;
 116 def FloatPtr : PtrType<FloatType>;
 117 def DoublePtr : PtrType<DoubleType>;
 118 def Float16Ptr : PtrType<Float16Type>;
 119 def Float128Ptr : PtrType<Float128Type>;
 120 def UnsignedCharPtr : PtrType<UnsignedCharType>;
 121
 122 def ConstDoublePtr : ConstType<DoublePtr>;
 123 def ConstFloatPtr : ConstType<FloatPtr>;
 124 def ConstLongDoublePtr : ConstType<LongDoublePtr>;
 125 def ConstFloat16Ptr : ConstType<Float16Ptr>;
 126 def ConstFloat128Ptr : ConstType<Float128Ptr>;
 127
 128 def SigHandlerT : NamedType<"__sighandler_t">;
 129
 130 def TimeTType : NamedType<"time_t">;
 131
 132 def StructTimeSpec : NamedType<"struct timespec">;
 133 def StructTimeSpecPtr : PtrType<StructTimeSpec>;
 134 def ConstStructTimeSpecPtr : ConstType<StructTimeSpecPtr>;
 135 def RestrictStructTimeSpecPtr : RestrictedPtrType<StructTimeSpec>;
 136 def ConstRestrictStructTimeSpecPtr : ConstType<RestrictStructTimeSpecPtr>;
 137
 138 def BSearchCompareT : NamedType<"__bsearchcompare_t">;
 139 def QSortCompareT : NamedType<"__qsortcompare_t">;
 140
 141 def AtexitHandlerT : NamedType<"__atexithandler_t">;
 142
 143 def FILE : NamedType<"FILE">;
 144 def FILEPtr : PtrType<FILE>;
 145 def FILERestrictedPtr : RestrictedPtrType<FILE>;
 146
 147 def PThreadTType : NamedType<"pthread_t">;
 148
 149 def PidT : NamedType<"pid_t">;
 150 def RestrictedPidTPtr : RestrictedPtrType<PidT>;
 151
 152 def StructRUsage : NamedType<"struct rusage">;
 153 def StructRUsagePtr : PtrType<StructRUsage>;
 154
 155 def StructTimevalType : NamedType<"struct timeval">;
 156 def StructTimevalPtr : PtrType<StructTimevalType>;
 157 def RestrictedStructTimevalPtr : RestrictedPtrType<StructTimevalType>;
 158
 159 def SuSecondsT : NamedType<"suseconds_t">;
 160
 161 //added because __assert_fail needs it.
 162 def UnsignedType : NamedType<"unsigned">;
 163
 164 def ActionType : NamedType<"ACTION">;
 165 def EntryType : NamedType<"ENTRY">;
 166 def EntryTypePtr : PtrType<EntryType>;
 167 def EntryTypePtrPtr : PtrType<EntryTypePtr>;
 168
 169 def MBStateTType : NamedType<"mbstate_t">;
 170
 171 class Macro<string name> {
 172   string Name = name;
 173 }
 174
 175 class EnumeratedNameValue<string name, string value = "__default__"> {
 176   string Name = name;
 177   string Value = value;
 178 }
 179
 180 class Annotation {}
 181
 182 class RetValSpec<Type type, list<Annotation> annotations = []> {
 183   Type ReturnType = type;
 184   list<Annotation> Annotations = annotations;
 185 }
 186
 187 class ArgSpec<Type type, list<Annotation> annotations = [], string name = ""> {
 188   Type ArgType = type;
 189   list<Annotation> Annotations = annotations;
 190   string Name = name;
 191 }
 192
 193 // The following classes are used to describe function attributes.
 194 // In the future, we may consider supporting parameter attributes as well.
 195 // https://clang.llvm.org/docs/AttributeReference.html
 196 class FunctionAttr<string style, string attr> {
 197   string Attr = attr;
 198   // The style of the attribute, e.g. "gnu", "cxx11", "declspec".
 199   // - "gnu" is for GNU-style attributes: __attribute__((...))
 200   // - "cxx11" is for C++11-style attributes: [[...]]
 201   // - "declspec" is for Microsoft-style attributes: __declspec(...)
 202   string Style = style;
 203
 204   // For the time being, we are only interested in identifer-like attributes.
 205   // We can extend this to support function-like attributes if needed.
 206   // For example, in the future, we can #define __LIBC_ATTRIBUTE_NODISCARD(...) [[nodiscard(__VA_ARGS__)]]
 207   // int FunctionLike = 0;
 208 }
 209 class GnuFunctionAttr<string attr> : FunctionAttr<"gnu", attr> {}
 210 class Cxx11FunctionAttr<string attr, string namespace> : FunctionAttr<"cxx11", attr> {
 211   // The namespace of the attribute, e.g. "gnu" or "clang". Empty string means there is no namespace.
 212   string Namespace = namespace;
 213 }
 214 class DeclspecFunctionAttr<string attr> : FunctionAttr<"declspec", attr> {}
 215 class FunctionAttrSpec<string macro, list<FunctionAttr> instances> {
 216   list<FunctionAttr> Instances = instances;
 217   string Macro = macro;
 218 }
 219
 220 class FunctionSpec<string name, RetValSpec return, list<ArgSpec> args, list<FunctionAttrSpec> attrs = []> {
 221   string Name = name;
 222   RetValSpec Return = return;
 223   list<ArgSpec> Args = args;
 224   list<FunctionAttrSpec> Attributes = attrs;
 225 }
 226
 227 class GuardedFunctionSpec<string name, RetValSpec return, list<ArgSpec> args, string guard_macro> : FunctionSpec<name, return, args> {
 228   string Guard = guard_macro;
 229 }
 230
 231 class ObjectSpec<string name, string type> {
 232   string Name = name;
 233   string Type = type;
 234 }
 235
 236 class HeaderSpec<string name,
 237                 list<Macro> macros = [],
 238                 list<Type> types = [],
 239                 list<EnumeratedNameValue> enumerations = [],
 240                 list<FunctionSpec> functions = [],
 241                 list<ObjectSpec> objects = []> {
 242   string Name = name;
 243   list<FunctionSpec> Functions = functions;
 244   list<Type> Types = types;
 245   list<Macro> Macros = macros;
 246   list<EnumeratedNameValue> Enumerations = enumerations;
 247   list<ObjectSpec> Objects = objects;
 248 }
 249
 250 class StandardSpec<string name> {
 251   string Name = name;
 252   list<HeaderSpec> Headers;
 253 }