[libclang] Expose AtomicType

[slowhog]

Summary

Expose atomic type through the C API.

[slowhog]

Hi,

We use libclang in OpenJDK project Panama for a tool, jextract, to read C header files and generate Java bindings. It's critical for us to be able get the "real" underlying type.

Currently type like _Atomic(int) are not exposed, and libclang will give us a type kind of CXType_Unexposed, and we need a way to get the value type of CXType_Int .

Is there an existing way to do that? I have tried to call clang_getCanonicalType on the unexposed type, but that return the same unexposed type.

Please let me know if the proposed patch is on the right track or not, I would appreciate guidance to get this issue solved.

[slowhog]

Updated to latest

[JornVernee]

Would like to try to draw attention to this patch again, since it seems to have gone under the radar. Can someone review this/help get it integrated? We are still having to work around _Atomic types because we can't get to the underlying value type. Thanks

[aaron.ballman]

I'm sorry about the delay in review, this did fall off my radar. Thank you for bringing it to my attention!

Looks mostly good to me, just a few small nits.

clang/include/clang-c/Index.h

3953

Missing a full stop at the end of the comment.

clang/tools/c-index-test/c-index-test.c

1585

Should elide braces here.

clang/tools/libclang/CXType.cpp

1326–1329

I would probably rewrite this function to:

QualType T = GetQualType(CT);
if (T.isNull() || !T->isAtomicType())
  return MakeCXType(QualType(), GetTU(CT));
const auto *AT = T->castAs<AtomicType>();
return MakeCXType(AT->getValueType(), GetTU(CT));

[slowhog]

Thanks for reviewing, I applied the recommended changes.

[aaron.ballman]

LGTM! Do you need me to commit on your behalf?

[slowhog]

Yes, please help to commit the patch. Thank you for looking after this.

[aaron.ballman]

I've commit on your behalf in 38ca7b11db2d22e0fdfbff3f19276f9796f747d3, thank you for the patch!

clang/include/clang-c/Index.h

  * The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * The policy about the libclang API was always to keep it source and ABI
  * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
  */
 #define CINDEX_VERSION_MAJOR 0
-#define CINDEX_VERSION_MINOR 56
+#define CINDEX_VERSION_MINOR 57
 
 #define CINDEX_VERSION_ENCODE(major, minor) ( \
       ((major) * 10000)                       \
     + ((minor) *     1))
 
 #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
     CINDEX_VERSION_MAJOR,                     \
     CINDEX_VERSION_MINOR )
enum CXTypeKind {
   CXType_OCLIntelSubgroupAVCRefResult = 170,
   CXType_OCLIntelSubgroupAVCSicResult = 171,
   CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172,
   CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173,
   CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174,
 
   CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175,
 
-  CXType_ExtVector = 176
+  CXType_ExtVector = 176,
+  CXType_Atomic = 177
 };
 
 /**
  * Describes the calling convention of a function type
  */
 enum CXCallingConv {
   CXCallingConv_Default = 0,
   CXCallingConv_C = 1,

 /**
  * Return the type that was modified by this attributed type.
  *
  * If the type is not an attributed type, an invalid type is returned.
  */
 CINDEX_LINKAGE CXType clang_Type_getModifiedType(CXType T);
 
 /**
+ * Gets the type contained by this atomic type
+ *
+ * If a non-atomic type is passed in, an invalid type is returned.
+ */
+CINDEX_LINKAGE CXType clang_Type_getValueType(CXType CT);
+
+/**
  * Return the offset of the field represented by the Cursor.
  *
  * If the cursor is not a field declaration, -1 is returned.
  * If the cursor semantic parent is not a record field declaration,
  *   CXTypeLayoutError_Invalid is returned.
  * If the field's type declaration is an incomplete type,
  *   CXTypeLayoutError_Incomplete is returned.
  * If the field's type declaration is a dependent type,
enum CXRefQualifierKind {
   CXRefQualifier_None = 0,
   /** An lvalue ref-qualifier was provided (\c &). */
   CXRefQualifier_LValue,
   /** An rvalue ref-qualifier was provided (\c &&). */
   CXRefQualifier_RValue
 };
 
 /**
  * Returns the number of template arguments for given template
  * specialization, or -1 if type \c T is not a template specialization.
  */
 CINDEX_LINKAGE int clang_Type_getNumTemplateArguments(CXType T);
 
 /**
  * Returns the type template argument of a template class specialization
  * at given index.
  *

clang/test/Index/print-type.c

 
 struct {
   int x;
   int y;
 } foo;
 
 struct {
   struct {
-    int x;
+    _Atomic int x;
     int y;
   };
 } bar;
 
 void fun(struct { int x; int y; } *param);
 
+_Atomic(unsigned long) aul;
+
 // RUN: c-index-test -test-print-type %s | FileCheck %s
 // CHECK: FunctionDecl=f:3:6 (Definition) [type=int *(int *, char *, FooType, int *, void (*)(int))] [typekind=FunctionProto] [canonicaltype=int *(int *, char *, int, int *, void (*)(int))] [canonicaltypekind=FunctionProto] [resulttype=int *] [resulttypekind=Pointer] [args= [int *] [Pointer] [char *] [Pointer] [FooType] [Typedef] [int [5]] [ConstantArray] [void (*)(int)] [Pointer]] [isPOD=0]
 // CHECK: ParmDecl=p:3:13 (Definition) [type=int *] [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
 // CHECK: ParmDecl=x:3:22 (Definition) [type=char *] [typekind=Pointer] [isPOD=1] [pointeetype=char] [pointeekind=Char_{{[US]}}]
 // CHECK: ParmDecl=z:3:33 (Definition) [type=FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: TypeRef=FooType:1:13 [type=FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: ParmDecl=arr:3:40 (Definition) [type=int [5]] [typekind=ConstantArray] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]

 // CHECK: FunctionDecl=elaboratedEnumType:15:25 [type=enum Enum ()] [typekind=FunctionNoProto] [canonicaltype=enum Enum ()] [canonicaltypekind=FunctionNoProto] [resulttype=enum Enum] [resulttypekind=Elaborated] [isPOD=0]
 // CHECK: TypeRef=enum Enum:15:6 [type=enum Enum] [typekind=Enum] [isPOD=1]
 // CHECK: StructDecl=Struct:16:8 (Definition) [type=struct Struct] [typekind=Record] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedStructType:16:32 [type=struct Struct ()] [typekind=FunctionNoProto] [canonicaltype=struct Struct ()] [canonicaltypekind=FunctionNoProto] [resulttype=struct Struct] [resulttypekind=Elaborated] [isPOD=0]
 // CHECK: TypeRef=struct Struct:16:8 [type=struct Struct] [typekind=Record] [isPOD=1]
 // CHECK: StructDecl=:18:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:18:1)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
 // CHECK: StructDecl=:23:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:23:1)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1] [isAnonRecDecl=0]
 // CHECK: StructDecl=:24:3 (Definition) [type=struct (anonymous at {{.*}}print-type.c:24:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=1]
+// CHECK: FieldDecl=x:25:17 (Definition) [type=_Atomic(int)] [typekind=Atomic] [valuetype=int] [valuetypekind=Int] [isPOD=0] [isAnonRecDecl=0]
+// CHECK: FieldDecl=y:26:9 (Definition) [type=int] [typekind=Int] [isPOD=1] [isAnonRecDecl=0]
 // CHECK: StructDecl=:30:10 (Definition) [type=struct (anonymous at {{.*}}print-type.c:30:10)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
+// CHECK: VarDecl=aul:32:24 [type=_Atomic(unsigned long)] [typekind=Atomic] [valuetype=unsigned long] [valuetypekind=ULong] [isPOD=0] [isAnonRecDecl=0]

clang/tools/c-index-test/c-index-test.c

if (!clang_isInvalid(clang_getCursorKind(cursor))) {
     /* Print the canonical type if it is different. */
     {
       CXType CT = clang_getCanonicalType(T);
       if (!clang_equalTypes(T, CT)) {
         PrintTypeAndTypeKind(CT, " [canonicaltype=%s] [canonicaltypekind=%s]");
         PrintTypeTemplateArgs(CT, " [canonicaltemplateargs/%d=");
       }
     }
+    /* Print the value type if it exists. */
+    {
+      CXType VT = clang_Type_getValueType(T);
+      if (VT.kind != CXType_Invalid) {
+        PrintTypeAndTypeKind(VT, " [valuetype=%s] [valuetypekind=%s]");
+      }
+    }
     /* Print the modified type if it exists. */
     {
       CXType MT = clang_Type_getModifiedType(T);
       if (MT.kind != CXType_Invalid) {
         PrintTypeAndTypeKind(MT, " [modifiedtype=%s] [modifiedtypekind=%s]");
       }
     }
     /* Print the return type if it exists. */
     {
       CXType RT = clang_getCursorResultType(cursor);
       if (RT.kind != CXType_Invalid) {

clang/tools/libclang/CXType.cpp

switch (TP->getTypeClass()) {
     TKCASE(DependentSizedArray);
     TKCASE(Vector);
     TKCASE(ExtVector);
     TKCASE(MemberPointer);
     TKCASE(Auto);
     TKCASE(Elaborated);
     TKCASE(Pipe);
     TKCASE(Attributed);
+    TKCASE(Atomic);
     default:
       return CXType_Unexposed;
   }
 #undef TKCASE
 }
 
 
 CXType cxtype::MakeCXType(QualType T, CXTranslationUnit TU) {

 #include "clang/Basic/OpenCLImageTypes.def"
 #undef IMAGE_TYPE
 #define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) TKIND(Id);
 #include "clang/Basic/OpenCLExtensionTypes.def"
     TKIND(OCLSampler);
     TKIND(OCLEvent);
     TKIND(OCLQueue);
     TKIND(OCLReserveID);
+    TKIND(Atomic);
   }
 #undef TKIND
   return cxstring::createRef(s);
 }
 
 unsigned clang_equalTypes(CXType A, CXType B) {
   return A.data[0] == B.data[0] && A.data[1] == B.data[1];
 }
switch (*nullability) {
       case NullabilityKind::Nullable:
         return CXTypeNullability_Nullable;
       case NullabilityKind::Unspecified:
         return CXTypeNullability_Unspecified;
     }
   }
   return CXTypeNullability_Invalid;
 }
+
+CXType clang_Type_getValueType(CXType CT) {
+  QualType T = GetQualType(CT);
+  const Type *TP = T.getTypePtrOrNull();
+
+  if (TP && TP->getTypeClass() == Type::Atomic)
+    return MakeCXType(cast<AtomicType>(TP)->getValueType(), GetTU(CT));
+
+  return MakeCXType(QualType(), GetTU(CT));
+}

clang/tools/libclang/libclang.exports

 clang_Type_isTransparentTagTypedef
 clang_Type_getObjCObjectBaseType
 clang_Type_getNumObjCProtocolRefs
 clang_Type_getObjCProtocolDecl
 clang_Type_getNumObjCTypeArgs
 clang_Type_getObjCTypeArg
 clang_Type_getModifiedType
 clang_Type_getNullability
+clang_Type_getValueType
 clang_VerbatimBlockLineComment_getText
 clang_VerbatimLineComment_getText
 clang_HTMLTagComment_getAsString
 clang_FullComment_getAsHTML
 clang_FullComment_getAsXML
 clang_annotateTokens
 clang_codeCompleteAt
 clang_codeCompleteGetContainerKind