From e816d592e8773c03ca92645d978669ec6de5ca0c Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 17 Jul 2019 17:45:24 -0400 Subject: [PATCH] update zig codebase to llvm 9 --- cmake/Findllvm.cmake | 1 + src-self-hosted/clang.zig | 426 +++++++++++++++++++------------------- src/link.cpp | 1 + src/target.cpp | 66 +++++- src/target.hpp | 1 + src/translate_c.cpp | 34 ++- src/zig_clang.cpp | 42 ++-- src/zig_clang.h | 194 +++++++++-------- 8 files changed, 422 insertions(+), 343 deletions(-) diff --git a/cmake/Findllvm.cmake b/cmake/Findllvm.cmake index 8a75f59a7c..96324a739f 100644 --- a/cmake/Findllvm.cmake +++ b/cmake/Findllvm.cmake @@ -59,6 +59,7 @@ NEED_TARGET("Mips") NEED_TARGET("MSP430") NEED_TARGET("NVPTX") NEED_TARGET("PowerPC") +NEED_TARGET("RISCV") NEED_TARGET("Sparc") NEED_TARGET("SystemZ") NEED_TARGET("WebAssembly") diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index f2433ae60c..5266f27371 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -148,6 +148,7 @@ pub const ZigClangTypeClass = extern enum { UnresolvedUsing, Paren, Typedef, + MacroQualified, Adjusted, Decayed, TypeOfExpr, @@ -176,210 +177,213 @@ pub const ZigClangTypeClass = extern enum { Atomic, }; -pub const ZigClangStmtClass = extern enum { - NoStmtClass = 0, - GCCAsmStmtClass = 1, - MSAsmStmtClass = 2, - AttributedStmtClass = 3, - BreakStmtClass = 4, - CXXCatchStmtClass = 5, - CXXForRangeStmtClass = 6, - CXXTryStmtClass = 7, - CapturedStmtClass = 8, - CompoundStmtClass = 9, - ContinueStmtClass = 10, - CoreturnStmtClass = 11, - CoroutineBodyStmtClass = 12, - DeclStmtClass = 13, - DoStmtClass = 14, - BinaryConditionalOperatorClass = 15, - ConditionalOperatorClass = 16, - AddrLabelExprClass = 17, - ArrayInitIndexExprClass = 18, - ArrayInitLoopExprClass = 19, - ArraySubscriptExprClass = 20, - ArrayTypeTraitExprClass = 21, - AsTypeExprClass = 22, - AtomicExprClass = 23, - BinaryOperatorClass = 24, - CompoundAssignOperatorClass = 25, - BlockExprClass = 26, - CXXBindTemporaryExprClass = 27, - CXXBoolLiteralExprClass = 28, - CXXConstructExprClass = 29, - CXXTemporaryObjectExprClass = 30, - CXXDefaultArgExprClass = 31, - CXXDefaultInitExprClass = 32, - CXXDeleteExprClass = 33, - CXXDependentScopeMemberExprClass = 34, - CXXFoldExprClass = 35, - CXXInheritedCtorInitExprClass = 36, - CXXNewExprClass = 37, - CXXNoexceptExprClass = 38, - CXXNullPtrLiteralExprClass = 39, - CXXPseudoDestructorExprClass = 40, - CXXScalarValueInitExprClass = 41, - CXXStdInitializerListExprClass = 42, - CXXThisExprClass = 43, - CXXThrowExprClass = 44, - CXXTypeidExprClass = 45, - CXXUnresolvedConstructExprClass = 46, - CXXUuidofExprClass = 47, - CallExprClass = 48, - CUDAKernelCallExprClass = 49, - CXXMemberCallExprClass = 50, - CXXOperatorCallExprClass = 51, - UserDefinedLiteralClass = 52, - CStyleCastExprClass = 53, - CXXFunctionalCastExprClass = 54, - CXXConstCastExprClass = 55, - CXXDynamicCastExprClass = 56, - CXXReinterpretCastExprClass = 57, - CXXStaticCastExprClass = 58, - ObjCBridgedCastExprClass = 59, - ImplicitCastExprClass = 60, - CharacterLiteralClass = 61, - ChooseExprClass = 62, - CompoundLiteralExprClass = 63, - ConvertVectorExprClass = 64, - CoawaitExprClass = 65, - CoyieldExprClass = 66, - DeclRefExprClass = 67, - DependentCoawaitExprClass = 68, - DependentScopeDeclRefExprClass = 69, - DesignatedInitExprClass = 70, - DesignatedInitUpdateExprClass = 71, - ExpressionTraitExprClass = 72, - ExtVectorElementExprClass = 73, - FixedPointLiteralClass = 74, - FloatingLiteralClass = 75, - ConstantExprClass = 76, - ExprWithCleanupsClass = 77, - FunctionParmPackExprClass = 78, - GNUNullExprClass = 79, - GenericSelectionExprClass = 80, - ImaginaryLiteralClass = 81, - ImplicitValueInitExprClass = 82, - InitListExprClass = 83, - IntegerLiteralClass = 84, - LambdaExprClass = 85, - MSPropertyRefExprClass = 86, - MSPropertySubscriptExprClass = 87, - MaterializeTemporaryExprClass = 88, - MemberExprClass = 89, - NoInitExprClass = 90, - OMPArraySectionExprClass = 91, - ObjCArrayLiteralClass = 92, - ObjCAvailabilityCheckExprClass = 93, - ObjCBoolLiteralExprClass = 94, - ObjCBoxedExprClass = 95, - ObjCDictionaryLiteralClass = 96, - ObjCEncodeExprClass = 97, - ObjCIndirectCopyRestoreExprClass = 98, - ObjCIsaExprClass = 99, - ObjCIvarRefExprClass = 100, - ObjCMessageExprClass = 101, - ObjCPropertyRefExprClass = 102, - ObjCProtocolExprClass = 103, - ObjCSelectorExprClass = 104, - ObjCStringLiteralClass = 105, - ObjCSubscriptRefExprClass = 106, - OffsetOfExprClass = 107, - OpaqueValueExprClass = 108, - UnresolvedLookupExprClass = 109, - UnresolvedMemberExprClass = 110, - PackExpansionExprClass = 111, - ParenExprClass = 112, - ParenListExprClass = 113, - PredefinedExprClass = 114, - PseudoObjectExprClass = 115, - ShuffleVectorExprClass = 116, - SizeOfPackExprClass = 117, - StmtExprClass = 118, - StringLiteralClass = 119, - SubstNonTypeTemplateParmExprClass = 120, - SubstNonTypeTemplateParmPackExprClass = 121, - TypeTraitExprClass = 122, - TypoExprClass = 123, - UnaryExprOrTypeTraitExprClass = 124, - UnaryOperatorClass = 125, - VAArgExprClass = 126, - ForStmtClass = 127, - GotoStmtClass = 128, - IfStmtClass = 129, - IndirectGotoStmtClass = 130, - LabelStmtClass = 131, - MSDependentExistsStmtClass = 132, - NullStmtClass = 133, - OMPAtomicDirectiveClass = 134, - OMPBarrierDirectiveClass = 135, - OMPCancelDirectiveClass = 136, - OMPCancellationPointDirectiveClass = 137, - OMPCriticalDirectiveClass = 138, - OMPFlushDirectiveClass = 139, - OMPDistributeDirectiveClass = 140, - OMPDistributeParallelForDirectiveClass = 141, - OMPDistributeParallelForSimdDirectiveClass = 142, - OMPDistributeSimdDirectiveClass = 143, - OMPForDirectiveClass = 144, - OMPForSimdDirectiveClass = 145, - OMPParallelForDirectiveClass = 146, - OMPParallelForSimdDirectiveClass = 147, - OMPSimdDirectiveClass = 148, - OMPTargetParallelForSimdDirectiveClass = 149, - OMPTargetSimdDirectiveClass = 150, - OMPTargetTeamsDistributeDirectiveClass = 151, - OMPTargetTeamsDistributeParallelForDirectiveClass = 152, - OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153, - OMPTargetTeamsDistributeSimdDirectiveClass = 154, - OMPTaskLoopDirectiveClass = 155, - OMPTaskLoopSimdDirectiveClass = 156, - OMPTeamsDistributeDirectiveClass = 157, - OMPTeamsDistributeParallelForDirectiveClass = 158, - OMPTeamsDistributeParallelForSimdDirectiveClass = 159, - OMPTeamsDistributeSimdDirectiveClass = 160, - OMPMasterDirectiveClass = 161, - OMPOrderedDirectiveClass = 162, - OMPParallelDirectiveClass = 163, - OMPParallelSectionsDirectiveClass = 164, - OMPSectionDirectiveClass = 165, - OMPSectionsDirectiveClass = 166, - OMPSingleDirectiveClass = 167, - OMPTargetDataDirectiveClass = 168, - OMPTargetDirectiveClass = 169, - OMPTargetEnterDataDirectiveClass = 170, - OMPTargetExitDataDirectiveClass = 171, - OMPTargetParallelDirectiveClass = 172, - OMPTargetParallelForDirectiveClass = 173, - OMPTargetTeamsDirectiveClass = 174, - OMPTargetUpdateDirectiveClass = 175, - OMPTaskDirectiveClass = 176, - OMPTaskgroupDirectiveClass = 177, - OMPTaskwaitDirectiveClass = 178, - OMPTaskyieldDirectiveClass = 179, - OMPTeamsDirectiveClass = 180, - ObjCAtCatchStmtClass = 181, - ObjCAtFinallyStmtClass = 182, - ObjCAtSynchronizedStmtClass = 183, - ObjCAtThrowStmtClass = 184, - ObjCAtTryStmtClass = 185, - ObjCAutoreleasePoolStmtClass = 186, - ObjCForCollectionStmtClass = 187, - ReturnStmtClass = 188, - SEHExceptStmtClass = 189, - SEHFinallyStmtClass = 190, - SEHLeaveStmtClass = 191, - SEHTryStmtClass = 192, - CaseStmtClass = 193, - DefaultStmtClass = 194, - SwitchStmtClass = 195, - WhileStmtClass = 196, +const ZigClangStmtClass = extern enum { + NoStmtClass, + GCCAsmStmtClass, + MSAsmStmtClass, + BreakStmtClass, + CXXCatchStmtClass, + CXXForRangeStmtClass, + CXXTryStmtClass, + CapturedStmtClass, + CompoundStmtClass, + ContinueStmtClass, + CoreturnStmtClass, + CoroutineBodyStmtClass, + DeclStmtClass, + DoStmtClass, + ForStmtClass, + GotoStmtClass, + IfStmtClass, + IndirectGotoStmtClass, + MSDependentExistsStmtClass, + NullStmtClass, + OMPAtomicDirectiveClass, + OMPBarrierDirectiveClass, + OMPCancelDirectiveClass, + OMPCancellationPointDirectiveClass, + OMPCriticalDirectiveClass, + OMPFlushDirectiveClass, + OMPDistributeDirectiveClass, + OMPDistributeParallelForDirectiveClass, + OMPDistributeParallelForSimdDirectiveClass, + OMPDistributeSimdDirectiveClass, + OMPForDirectiveClass, + OMPForSimdDirectiveClass, + OMPParallelForDirectiveClass, + OMPParallelForSimdDirectiveClass, + OMPSimdDirectiveClass, + OMPTargetParallelForSimdDirectiveClass, + OMPTargetSimdDirectiveClass, + OMPTargetTeamsDistributeDirectiveClass, + OMPTargetTeamsDistributeParallelForDirectiveClass, + OMPTargetTeamsDistributeParallelForSimdDirectiveClass, + OMPTargetTeamsDistributeSimdDirectiveClass, + OMPTaskLoopDirectiveClass, + OMPTaskLoopSimdDirectiveClass, + OMPTeamsDistributeDirectiveClass, + OMPTeamsDistributeParallelForDirectiveClass, + OMPTeamsDistributeParallelForSimdDirectiveClass, + OMPTeamsDistributeSimdDirectiveClass, + OMPMasterDirectiveClass, + OMPOrderedDirectiveClass, + OMPParallelDirectiveClass, + OMPParallelSectionsDirectiveClass, + OMPSectionDirectiveClass, + OMPSectionsDirectiveClass, + OMPSingleDirectiveClass, + OMPTargetDataDirectiveClass, + OMPTargetDirectiveClass, + OMPTargetEnterDataDirectiveClass, + OMPTargetExitDataDirectiveClass, + OMPTargetParallelDirectiveClass, + OMPTargetParallelForDirectiveClass, + OMPTargetTeamsDirectiveClass, + OMPTargetUpdateDirectiveClass, + OMPTaskDirectiveClass, + OMPTaskgroupDirectiveClass, + OMPTaskwaitDirectiveClass, + OMPTaskyieldDirectiveClass, + OMPTeamsDirectiveClass, + ObjCAtCatchStmtClass, + ObjCAtFinallyStmtClass, + ObjCAtSynchronizedStmtClass, + ObjCAtThrowStmtClass, + ObjCAtTryStmtClass, + ObjCAutoreleasePoolStmtClass, + ObjCForCollectionStmtClass, + ReturnStmtClass, + SEHExceptStmtClass, + SEHFinallyStmtClass, + SEHLeaveStmtClass, + SEHTryStmtClass, + CaseStmtClass, + DefaultStmtClass, + SwitchStmtClass, + AttributedStmtClass, + BinaryConditionalOperatorClass, + ConditionalOperatorClass, + AddrLabelExprClass, + ArrayInitIndexExprClass, + ArrayInitLoopExprClass, + ArraySubscriptExprClass, + ArrayTypeTraitExprClass, + AsTypeExprClass, + AtomicExprClass, + BinaryOperatorClass, + CompoundAssignOperatorClass, + BlockExprClass, + CXXBindTemporaryExprClass, + CXXBoolLiteralExprClass, + CXXConstructExprClass, + CXXTemporaryObjectExprClass, + CXXDefaultArgExprClass, + CXXDefaultInitExprClass, + CXXDeleteExprClass, + CXXDependentScopeMemberExprClass, + CXXFoldExprClass, + CXXInheritedCtorInitExprClass, + CXXNewExprClass, + CXXNoexceptExprClass, + CXXNullPtrLiteralExprClass, + CXXPseudoDestructorExprClass, + CXXScalarValueInitExprClass, + CXXStdInitializerListExprClass, + CXXThisExprClass, + CXXThrowExprClass, + CXXTypeidExprClass, + CXXUnresolvedConstructExprClass, + CXXUuidofExprClass, + CallExprClass, + CUDAKernelCallExprClass, + CXXMemberCallExprClass, + CXXOperatorCallExprClass, + UserDefinedLiteralClass, + BuiltinBitCastExprClass, + CStyleCastExprClass, + CXXFunctionalCastExprClass, + CXXConstCastExprClass, + CXXDynamicCastExprClass, + CXXReinterpretCastExprClass, + CXXStaticCastExprClass, + ObjCBridgedCastExprClass, + ImplicitCastExprClass, + CharacterLiteralClass, + ChooseExprClass, + CompoundLiteralExprClass, + ConvertVectorExprClass, + CoawaitExprClass, + CoyieldExprClass, + DeclRefExprClass, + DependentCoawaitExprClass, + DependentScopeDeclRefExprClass, + DesignatedInitExprClass, + DesignatedInitUpdateExprClass, + ExpressionTraitExprClass, + ExtVectorElementExprClass, + FixedPointLiteralClass, + FloatingLiteralClass, + ConstantExprClass, + ExprWithCleanupsClass, + FunctionParmPackExprClass, + GNUNullExprClass, + GenericSelectionExprClass, + ImaginaryLiteralClass, + ImplicitValueInitExprClass, + InitListExprClass, + IntegerLiteralClass, + LambdaExprClass, + MSPropertyRefExprClass, + MSPropertySubscriptExprClass, + MaterializeTemporaryExprClass, + MemberExprClass, + NoInitExprClass, + OMPArraySectionExprClass, + ObjCArrayLiteralClass, + ObjCAvailabilityCheckExprClass, + ObjCBoolLiteralExprClass, + ObjCBoxedExprClass, + ObjCDictionaryLiteralClass, + ObjCEncodeExprClass, + ObjCIndirectCopyRestoreExprClass, + ObjCIsaExprClass, + ObjCIvarRefExprClass, + ObjCMessageExprClass, + ObjCPropertyRefExprClass, + ObjCProtocolExprClass, + ObjCSelectorExprClass, + ObjCStringLiteralClass, + ObjCSubscriptRefExprClass, + OffsetOfExprClass, + OpaqueValueExprClass, + UnresolvedLookupExprClass, + UnresolvedMemberExprClass, + PackExpansionExprClass, + ParenExprClass, + ParenListExprClass, + PredefinedExprClass, + PseudoObjectExprClass, + ShuffleVectorExprClass, + SizeOfPackExprClass, + SourceLocExprClass, + StmtExprClass, + StringLiteralClass, + SubstNonTypeTemplateParmExprClass, + SubstNonTypeTemplateParmPackExprClass, + TypeTraitExprClass, + TypoExprClass, + UnaryExprOrTypeTraitExprClass, + UnaryOperatorClass, + VAArgExprClass, + LabelStmtClass, + WhileStmtClass, }; pub const ZigClangCK = extern enum { Dependent, BitCast, LValueBitCast, + LValueToRValueBitCast, LValueToRValue, NoOp, BaseToDerived, @@ -406,6 +410,8 @@ pub const ZigClangCK = extern enum { IntegralToBoolean, IntegralToFloating, FixedPointCast, + FixedPointToIntegral, + IntegralToFixedPoint, FixedPointToBoolean, FloatingToIntegral, FloatingToBoolean, @@ -439,9 +445,11 @@ pub const ZigClangCK = extern enum { }; pub const ZigClangAPValueKind = extern enum { - Uninitialized, + None, + Indeterminate, Int, Float, + FixedPoint, ComplexInt, ComplexFloat, LValue, @@ -478,6 +486,7 @@ pub const ZigClangDeclKind = extern enum { ObjCMethod, ObjCProperty, BuiltinTemplate, + Concept, ClassTemplate, FunctionTemplate, TypeAliasTemplate, @@ -519,8 +528,10 @@ pub const ZigClangDeclKind = extern enum { VarTemplatePartialSpecialization, EnumConstant, IndirectField, + OMPDeclareMapper, OMPDeclareReduction, UnresolvedUsingValue, + OMPAllocate, OMPRequires, OMPThreadPrivate, ObjCPropertyImpl, @@ -939,25 +950,10 @@ pub const struct_ZigClangExprEvalResult = extern struct { }; pub const struct_ZigClangAPValue = extern struct { - Kind: ZigClangAPValue_ValueKind, + Kind: ZigClangAPValueKind, Data: if (builtin.os == .windows and builtin.abi == .msvc) [52]u8 else [68]u8, }; -pub const ZigClangAPValue_ValueKind = extern enum { - ZigClangAPValue_ValueKind_Uninitialized, - ZigClangAPValue_ValueKind_Int, - ZigClangAPValue_ValueKind_Float, - ZigClangAPValue_ValueKind_ComplexInt, - ZigClangAPValue_ValueKind_ComplexFloat, - ZigClangAPValue_ValueKind_LValue, - ZigClangAPValue_ValueKind_Vector, - ZigClangAPValue_ValueKind_Array, - ZigClangAPValue_ValueKind_Struct, - ZigClangAPValue_ValueKind_Union, - ZigClangAPValue_ValueKind_MemberPointer, - ZigClangAPValue_ValueKind_AddrLabelDiff, -}; - pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const ZigClangIntegerLiteral, *ZigClangExprEvalResult, *const ZigClangASTContext) bool; pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation; diff --git a/src/link.cpp b/src/link.cpp index 44b3abaa90..88267f6cac 100644 --- a/src/link.cpp +++ b/src/link.cpp @@ -2520,6 +2520,7 @@ static void construct_linker_job_macho(LinkJob *lj) { static void construct_linker_job(LinkJob *lj) { switch (target_object_format(lj->codegen->zig_target)) { case ZigLLVM_UnknownObjectFormat: + case ZigLLVM_XCOFF: zig_unreachable(); case ZigLLVM_COFF: diff --git a/src/target.cpp b/src/target.cpp index 1c5a34e54f..fd5deeea29 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -235,6 +235,7 @@ const char *target_oformat_name(ZigLLVM_ObjectFormatType oformat) { case ZigLLVM_ELF: return "elf"; case ZigLLVM_MachO: return "macho"; case ZigLLVM_Wasm: return "wasm"; + case ZigLLVM_XCOFF: return "xcoff"; } zig_unreachable(); } @@ -337,6 +338,8 @@ ZigLLVM_OSType get_llvm_os_type(Os os_type) { return ZigLLVM_Hurd; case OsWASI: return ZigLLVM_WASI; + case OsEmscripten: + return ZigLLVM_Emscripten; } zig_unreachable(); } @@ -412,6 +415,8 @@ static Os get_zig_os_type(ZigLLVM_OSType os_type) { return OsHurd; case ZigLLVM_WASI: return OsWASI; + case ZigLLVM_Emscripten: + return OsEmscripten; } zig_unreachable(); } @@ -457,6 +462,7 @@ const char *target_os_name(Os os_type) { case OsHermitCore: case OsHurd: case OsWASI: + case OsEmscripten: return ZigLLVMGetOSTypeName(get_llvm_os_type(os_type)); } zig_unreachable(); @@ -569,6 +575,7 @@ SubArchList target_subarch_list(ZigLLVM_ArchType arch) { case ZigLLVM_aarch64: case ZigLLVM_aarch64_be: + case ZigLLVM_aarch64_32: return SubArchListArm64; case ZigLLVM_kalimba: @@ -843,6 +850,7 @@ uint32_t target_arch_pointer_bit_width(ZigLLVM_ArchType arch) { case ZigLLVM_shave: case ZigLLVM_wasm32: case ZigLLVM_renderscript32: + case ZigLLVM_aarch64_32: return 32; case ZigLLVM_aarch64: @@ -916,6 +924,7 @@ uint32_t target_c_type_size_in_bits(const ZigTarget *target, CIntType id) { case OsNetBSD: case OsOpenBSD: case OsWASI: + case OsEmscripten: switch (id) { case CIntTypeShort: case CIntTypeUShort: @@ -1091,7 +1100,40 @@ static bool is_64_bit(ZigLLVM_ArchType arch) { return target_arch_pointer_bit_width(arch) == 64; } +bool target_is_android(const ZigTarget *target) { + return target->abi == ZigLLVM_Android; +} + const char *target_dynamic_linker(const ZigTarget *target) { + if (target_is_android(target)) { + return is_64_bit(target->arch) ? "/system/bin/linker64" : "/system/bin/linker"; + } + + if (target_is_musl(target)) { + Buf buf = BUF_INIT; + buf_init_from_str(&buf, "/lib/ld-musl-"); + bool is_arm = false; + switch (target->arch) { + case ZigLLVM_arm: + case ZigLLVM_thumb: + buf_append_str(&buf, "arm"); + is_arm = true; + break; + case ZigLLVM_armeb: + case ZigLLVM_thumbeb: + buf_append_str(&buf, "armeb"); + is_arm = true; + break; + default: + buf_append_str(&buf, target_arch_name(target->arch)); + } + if (is_arm && get_float_abi(target) == FloatAbiHard) { + buf_append_str(&buf, "hf"); + } + buf_append_str(&buf, ".so.1"); + return buf_ptr(&buf); + } + switch (target->os) { case OsFreeBSD: return "/libexec/ld-elf.so.1"; @@ -1099,14 +1141,6 @@ const char *target_dynamic_linker(const ZigTarget *target) { return "/libexec/ld.elf_so"; case OsLinux: { const ZigLLVM_EnvironmentType abi = target->abi; - if (abi == ZigLLVM_Android) { - if (is_64_bit(target->arch)) { - return "/system/bin/linker64"; - } else { - return "/system/bin/linker"; - } - } - switch (target->arch) { case ZigLLVM_UnknownArch: zig_unreachable(); @@ -1121,6 +1155,9 @@ const char *target_dynamic_linker(const ZigTarget *target) { case ZigLLVM_aarch64_be: return "/lib/ld-linux-aarch64_be.so.1"; + case ZigLLVM_aarch64_32: + return "/lib/ld-linux-aarch64_32.so.1"; + case ZigLLVM_arm: case ZigLLVM_thumb: if (get_float_abi(target) == FloatAbiHard) { @@ -1213,6 +1250,7 @@ const char *target_dynamic_linker(const ZigTarget *target) { case OsMacOSX: case OsUefi: case OsWindows: + case OsEmscripten: return nullptr; case OsAnanas: @@ -1280,11 +1318,12 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) { case ZigLLVM_x86_64: return "rsp"; case ZigLLVM_aarch64: + case ZigLLVM_aarch64_be: + case ZigLLVM_aarch64_32: return "sp"; case ZigLLVM_arm: case ZigLLVM_thumb: - case ZigLLVM_aarch64_be: case ZigLLVM_amdgcn: case ZigLLVM_amdil: case ZigLLVM_amdil64: @@ -1338,10 +1377,11 @@ bool target_is_arm(const ZigTarget *target) { case ZigLLVM_UnknownArch: zig_unreachable(); case ZigLLVM_aarch64: - case ZigLLVM_arm: - case ZigLLVM_thumb: case ZigLLVM_aarch64_be: + case ZigLLVM_aarch64_32: + case ZigLLVM_arm: case ZigLLVM_armeb: + case ZigLLVM_thumb: case ZigLLVM_thumbeb: return true; @@ -1490,6 +1530,7 @@ ZigLLVM_EnvironmentType target_default_abi(ZigLLVM_ArchType arch, Os os) { return ZigLLVM_MSVC; case OsLinux: case OsWASI: + case OsEmscripten: return ZigLLVM_Musl; } zig_unreachable(); @@ -1607,12 +1648,15 @@ const char *target_libc_generic_name(const ZigTarget *target) { case ZigLLVM_CODE16: case ZigLLVM_EABI: case ZigLLVM_EABIHF: + case ZigLLVM_ELFv1: + case ZigLLVM_ELFv2: case ZigLLVM_Android: case ZigLLVM_MSVC: case ZigLLVM_Itanium: case ZigLLVM_Cygnus: case ZigLLVM_CoreCLR: case ZigLLVM_Simulator: + case ZigLLVM_MacABI: zig_unreachable(); } zig_unreachable(); diff --git a/src/target.hpp b/src/target.hpp index 0e7dc6686d..85768347a5 100644 --- a/src/target.hpp +++ b/src/target.hpp @@ -186,6 +186,7 @@ bool target_abi_is_musl(ZigLLVM_EnvironmentType abi); bool target_is_glibc(const ZigTarget *target); bool target_is_musl(const ZigTarget *target); bool target_is_wasm(const ZigTarget *target); +bool target_is_android(const ZigTarget *target); bool target_is_single_threaded(const ZigTarget *target); bool target_supports_stack_probing(const ZigTarget *target); bool target_has_debug_info(const ZigTarget *target); diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 69c70958e5..706f4706b0 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -1301,6 +1301,7 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc case ZigClangType_DeducedTemplateSpecialization: case ZigClangType_DependentAddressSpace: case ZigClangType_DependentVector: + case ZigClangType_MacroQualified: emit_warning(c, source_loc, "unsupported type: '%s'", ZigClangType_getTypeClassName(ty)); return nullptr; } @@ -2188,6 +2189,15 @@ static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, Tra case ZigClangCK_IntToOCLSampler: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntToOCLSampler"); return nullptr; + case ZigClangCK_LValueToRValueBitCast: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_LValueToRValueBitCast"); + return nullptr; + case ZigClangCK_FixedPointToIntegral: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointToIntegral"); + return nullptr; + case ZigClangCK_IntegralToFixedPoint: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToFixedPointral"); + return nullptr; } zig_unreachable(); } @@ -2671,6 +2681,15 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D case clang::Decl::TranslationUnit: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TranslationUnit"); return ErrorUnexpected; + case clang::Decl::Concept: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Concept"); + return ErrorUnexpected; + case clang::Decl::OMPDeclareMapper: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDeclareMapper"); + return ErrorUnexpected; + case clang::Decl::OMPAllocate: + emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPAllocate"); + return ErrorUnexpected; } zig_unreachable(); } @@ -2946,6 +2965,7 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * case ZigClangType_DeducedTemplateSpecialization: case ZigClangType_DependentAddressSpace: case ZigClangType_DependentVector: + case ZigClangType_MacroQualified: return res; } zig_unreachable(); @@ -4031,6 +4051,12 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s case ZigClangStmt_SEHTryStmtClass: emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHTryStmtClass"); return ErrorUnexpected; + case ZigClangStmt_BuiltinBitCastExprClass: + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C BuiltinBitCastExprClass"); + return ErrorUnexpected; + case ZigClangStmt_SourceLocExprClass: + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SourceLocExprClass"); + return ErrorUnexpected; } zig_unreachable(); } @@ -4448,7 +4474,7 @@ static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigC switch (ZigClangAPValue_getKind(ap_value)) { case ZigClangAPValueInt: return trans_create_node_apint(c, ZigClangAPValue_getInt(ap_value)); - case ZigClangAPValueUninitialized: + case ZigClangAPValueNone: return trans_create_node(c, NodeTypeUndefinedLiteral); case ZigClangAPValueArray: { emit_warning(c, source_loc, "TODO add a test case for this code"); @@ -4539,6 +4565,12 @@ static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigC case ZigClangAPValueAddrLabelDiff: emit_warning(c, source_loc, "unsupported initializer value kind: AddrLabelDiff"); return nullptr; + case ZigClangAPValueIndeterminate: + emit_warning(c, source_loc, "unsupported initializer value kind: Indeterminate"); + return nullptr; + case ZigClangAPValueFixedPoint: + emit_warning(c, source_loc, "unsupported initializer value kind: FixedPoint"); + return nullptr; } zig_unreachable(); } diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 7c87f31125..3ace615365 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -182,6 +182,7 @@ void ZigClang_detect_enum_CK(clang::CastKind x) { case clang::CK_IntegralToFloating: case clang::CK_IntegralToPointer: case clang::CK_LValueBitCast: + case clang::CK_LValueToRValueBitCast: case clang::CK_LValueToRValue: case clang::CK_MemberPointerToBoolean: case clang::CK_NoOp: @@ -199,6 +200,8 @@ void ZigClang_detect_enum_CK(clang::CastKind x) { case clang::CK_VectorSplat: case clang::CK_ZeroToOCLOpaqueType: case clang::CK_FixedPointCast: + case clang::CK_FixedPointToIntegral: + case clang::CK_IntegralToFixedPoint: case clang::CK_FixedPointToBoolean: break; } @@ -207,6 +210,7 @@ void ZigClang_detect_enum_CK(clang::CastKind x) { static_assert((clang::CastKind)ZigClangCK_Dependent == clang::CK_Dependent, ""); static_assert((clang::CastKind)ZigClangCK_BitCast == clang::CK_BitCast, ""); static_assert((clang::CastKind)ZigClangCK_LValueBitCast == clang::CK_LValueBitCast, ""); +static_assert((clang::CastKind)ZigClangCK_LValueToRValueBitCast == clang::CK_LValueToRValueBitCast, ""); static_assert((clang::CastKind)ZigClangCK_LValueToRValue == clang::CK_LValueToRValue, ""); static_assert((clang::CastKind)ZigClangCK_NoOp == clang::CK_NoOp, ""); static_assert((clang::CastKind)ZigClangCK_BaseToDerived == clang::CK_BaseToDerived, ""); @@ -233,6 +237,8 @@ static_assert((clang::CastKind)ZigClangCK_IntegralCast == clang::CK_IntegralCast static_assert((clang::CastKind)ZigClangCK_IntegralToBoolean == clang::CK_IntegralToBoolean, ""); static_assert((clang::CastKind)ZigClangCK_IntegralToFloating == clang::CK_IntegralToFloating, ""); static_assert((clang::CastKind)ZigClangCK_FixedPointCast == clang::CK_FixedPointCast, ""); +static_assert((clang::CastKind)ZigClangCK_FixedPointToIntegral == clang::CK_FixedPointToIntegral, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralToFixedPoint == clang::CK_IntegralToFixedPoint, ""); static_assert((clang::CastKind)ZigClangCK_FixedPointToBoolean == clang::CK_FixedPointToBoolean, ""); static_assert((clang::CastKind)ZigClangCK_FloatingToIntegral == clang::CK_FloatingToIntegral, ""); static_assert((clang::CastKind)ZigClangCK_FloatingToBoolean == clang::CK_FloatingToBoolean, ""); @@ -288,6 +294,7 @@ void ZigClang_detect_enum_TypeClass(clang::Type::TypeClass ty) { case clang::Type::UnresolvedUsing: case clang::Type::Paren: case clang::Type::Typedef: + case clang::Type::MacroQualified: case clang::Type::Adjusted: case clang::Type::Decayed: case clang::Type::TypeOfExpr: @@ -339,6 +346,7 @@ static_assert((clang::Type::TypeClass)ZigClangType_FunctionNoProto == clang::Typ static_assert((clang::Type::TypeClass)ZigClangType_UnresolvedUsing == clang::Type::UnresolvedUsing, ""); static_assert((clang::Type::TypeClass)ZigClangType_Paren == clang::Type::Paren, ""); static_assert((clang::Type::TypeClass)ZigClangType_Typedef == clang::Type::Typedef, ""); +static_assert((clang::Type::TypeClass)ZigClangType_MacroQualified == clang::Type::MacroQualified, ""); static_assert((clang::Type::TypeClass)ZigClangType_Adjusted == clang::Type::Adjusted, ""); static_assert((clang::Type::TypeClass)ZigClangType_Decayed == clang::Type::Decayed, ""); static_assert((clang::Type::TypeClass)ZigClangType_TypeOfExpr == clang::Type::TypeOfExpr, ""); @@ -423,6 +431,7 @@ void ZigClang_detect_enum_StmtClass(clang::Stmt::StmtClass x) { case clang::Stmt::ConditionalOperatorClass: case clang::Stmt::BinaryConditionalOperatorClass: case clang::Stmt::ImplicitCastExprClass: + case clang::Stmt::BuiltinBitCastExprClass: case clang::Stmt::CStyleCastExprClass: case clang::Stmt::CompoundLiteralExprClass: case clang::Stmt::ExtVectorElementExprClass: @@ -479,6 +488,7 @@ void ZigClang_detect_enum_StmtClass(clang::Stmt::StmtClass x) { case clang::Stmt::CXXNoexceptExprClass: case clang::Stmt::PackExpansionExprClass: case clang::Stmt::SizeOfPackExprClass: + case clang::Stmt::SourceLocExprClass: case clang::Stmt::SubstNonTypeTemplateParmExprClass: case clang::Stmt::SubstNonTypeTemplateParmPackExprClass: case clang::Stmt::FunctionParmPackExprClass: @@ -624,6 +634,7 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundAssignOperatorClass = static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConditionalOperatorClass == clang::Stmt::ConditionalOperatorClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_BinaryConditionalOperatorClass == clang::Stmt::BinaryConditionalOperatorClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImplicitCastExprClass == clang::Stmt::ImplicitCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_BuiltinBitCastExprClass == clang::Stmt::BuiltinBitCastExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_CStyleCastExprClass == clang::Stmt::CStyleCastExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundLiteralExprClass == clang::Stmt::CompoundLiteralExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExtVectorElementExprClass == clang::Stmt::ExtVectorElementExprClass, ""); @@ -680,6 +691,7 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnresolvedMemberExprClass == static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNoexceptExprClass == clang::Stmt::CXXNoexceptExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_PackExpansionExprClass == clang::Stmt::PackExpansionExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_SizeOfPackExprClass == clang::Stmt::SizeOfPackExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SourceLocExprClass == clang::Stmt::SourceLocExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmExprClass == clang::Stmt::SubstNonTypeTemplateParmExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmPackExprClass == clang::Stmt::SubstNonTypeTemplateParmPackExprClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_FunctionParmPackExprClass == clang::Stmt::FunctionParmPackExprClass, ""); @@ -770,9 +782,11 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeSimdD void ZigClang_detect_enum_APValueKind(clang::APValue::ValueKind x) { switch (x) { - case clang::APValue::Uninitialized: + case clang::APValue::None: + case clang::APValue::Indeterminate: case clang::APValue::Int: case clang::APValue::Float: + case clang::APValue::FixedPoint: case clang::APValue::ComplexInt: case clang::APValue::ComplexFloat: case clang::APValue::LValue: @@ -786,9 +800,11 @@ void ZigClang_detect_enum_APValueKind(clang::APValue::ValueKind x) { } } -static_assert((clang::APValue::ValueKind)ZigClangAPValueUninitialized == clang::APValue::Uninitialized, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueNone == clang::APValue::None, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueIndeterminate == clang::APValue::Indeterminate, ""); static_assert((clang::APValue::ValueKind)ZigClangAPValueInt == clang::APValue::Int, ""); static_assert((clang::APValue::ValueKind)ZigClangAPValueFloat == clang::APValue::Float, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueFixedPoint == clang::APValue::FixedPoint, ""); static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexInt == clang::APValue::ComplexInt, ""); static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexFloat == clang::APValue::ComplexFloat, ""); static_assert((clang::APValue::ValueKind)ZigClangAPValueLValue == clang::APValue::LValue, ""); @@ -826,6 +842,7 @@ void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) { case clang::Decl::ObjCMethod: case clang::Decl::ObjCProperty: case clang::Decl::BuiltinTemplate: + case clang::Decl::Concept: case clang::Decl::ClassTemplate: case clang::Decl::FunctionTemplate: case clang::Decl::TypeAliasTemplate: @@ -867,8 +884,10 @@ void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) { case clang::Decl::VarTemplatePartialSpecialization: case clang::Decl::EnumConstant: case clang::Decl::IndirectField: + case clang::Decl::OMPDeclareMapper: case clang::Decl::OMPDeclareReduction: case clang::Decl::UnresolvedUsingValue: + case clang::Decl::OMPAllocate: case clang::Decl::OMPRequires: case clang::Decl::OMPThreadPrivate: case clang::Decl::ObjCPropertyImpl: @@ -904,6 +923,7 @@ static_assert((clang::Decl::Kind)ZigClangDeclObjCProtocol == clang::Decl::ObjCPr static_assert((clang::Decl::Kind)ZigClangDeclObjCMethod == clang::Decl::ObjCMethod, ""); static_assert((clang::Decl::Kind)ZigClangDeclObjCProperty == clang::Decl::ObjCProperty, ""); static_assert((clang::Decl::Kind)ZigClangDeclBuiltinTemplate == clang::Decl::BuiltinTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclConcept == clang::Decl::Concept, ""); static_assert((clang::Decl::Kind)ZigClangDeclClassTemplate == clang::Decl::ClassTemplate, ""); static_assert((clang::Decl::Kind)ZigClangDeclFunctionTemplate == clang::Decl::FunctionTemplate, ""); static_assert((clang::Decl::Kind)ZigClangDeclTypeAliasTemplate == clang::Decl::TypeAliasTemplate, ""); @@ -919,6 +939,7 @@ static_assert((clang::Decl::Kind)ZigClangDeclObjCTypeParam == clang::Decl::ObjCT static_assert((clang::Decl::Kind)ZigClangDeclTypeAlias == clang::Decl::TypeAlias, ""); static_assert((clang::Decl::Kind)ZigClangDeclTypedef == clang::Decl::Typedef, ""); static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingTypename == clang::Decl::UnresolvedUsingTypename, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPAllocate == clang::Decl::OMPAllocate, ""); static_assert((clang::Decl::Kind)ZigClangDeclUsing == clang::Decl::Using, ""); static_assert((clang::Decl::Kind)ZigClangDeclUsingDirective == clang::Decl::UsingDirective, ""); static_assert((clang::Decl::Kind)ZigClangDeclUsingPack == clang::Decl::UsingPack, ""); @@ -945,6 +966,7 @@ static_assert((clang::Decl::Kind)ZigClangDeclVarTemplateSpecialization == clang: static_assert((clang::Decl::Kind)ZigClangDeclVarTemplatePartialSpecialization == clang::Decl::VarTemplatePartialSpecialization, ""); static_assert((clang::Decl::Kind)ZigClangDeclEnumConstant == clang::Decl::EnumConstant, ""); static_assert((clang::Decl::Kind)ZigClangDeclIndirectField == clang::Decl::IndirectField, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPDeclareMapper == clang::Decl::OMPDeclareMapper, ""); static_assert((clang::Decl::Kind)ZigClangDeclOMPDeclareReduction == clang::Decl::OMPDeclareReduction, ""); static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingValue == clang::Decl::UnresolvedUsingValue, ""); static_assert((clang::Decl::Kind)ZigClangDeclOMPRequires == clang::Decl::OMPRequires, ""); @@ -1288,19 +1310,6 @@ static_assert((clang::StringLiteral::StringKind)ZigClangStringLiteral_StringKind static_assert((clang::StringLiteral::StringKind)ZigClangStringLiteral_StringKind_UTF16 == clang::StringLiteral::UTF16, ""); static_assert((clang::StringLiteral::StringKind)ZigClangStringLiteral_StringKind_UTF32 == clang::StringLiteral::UTF32, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Uninitialized == clang::APValue::ValueKind::Uninitialized, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Int == clang::APValue::ValueKind::Int, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Float == clang::APValue::ValueKind::Float, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_ComplexInt == clang::APValue::ValueKind::ComplexInt, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_ComplexFloat == clang::APValue::ValueKind::ComplexFloat, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_LValue == clang::APValue::ValueKind::LValue, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Vector == clang::APValue::ValueKind::Vector, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Array == clang::APValue::ValueKind::Array, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Struct == clang::APValue::ValueKind::Struct, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_Union == clang::APValue::ValueKind::Union, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_MemberPointer == clang::APValue::ValueKind::MemberPointer, ""); -static_assert((clang::APValue::ValueKind)ZigClangAPValue_ValueKind_AddrLabelDiff == clang::APValue::ValueKind::AddrLabelDiff, ""); - static_assert(sizeof(ZigClangAPValue) == sizeof(clang::APValue), ""); static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); @@ -1744,7 +1753,6 @@ ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char std::shared_ptr pch_container_ops = std::make_shared(); bool only_local_decls = true; - bool capture_diagnostics = true; bool user_files_are_volatile = true; bool allow_pch_with_compiler_errors = false; bool single_file_parse = false; @@ -1753,7 +1761,7 @@ ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char clang::ASTUnit *ast_unit = clang::ASTUnit::LoadFromCommandLine( args_begin, args_end, pch_container_ops, diags, resources_path, - only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete, + only_local_decls, clang::CaptureDiagsKind::All, clang::None, true, 0, clang::TU_Complete, false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None, single_file_parse, user_files_are_volatile, for_serialization, clang::None, err_unit, nullptr); diff --git a/src/zig_clang.h b/src/zig_clang.h index 9d03b592fd..3891b0fac6 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -30,23 +30,25 @@ struct ZigClangAPValueLValueBase { unsigned Version; }; -enum ZigClangAPValue_ValueKind { - ZigClangAPValue_ValueKind_Uninitialized, - ZigClangAPValue_ValueKind_Int, - ZigClangAPValue_ValueKind_Float, - ZigClangAPValue_ValueKind_ComplexInt, - ZigClangAPValue_ValueKind_ComplexFloat, - ZigClangAPValue_ValueKind_LValue, - ZigClangAPValue_ValueKind_Vector, - ZigClangAPValue_ValueKind_Array, - ZigClangAPValue_ValueKind_Struct, - ZigClangAPValue_ValueKind_Union, - ZigClangAPValue_ValueKind_MemberPointer, - ZigClangAPValue_ValueKind_AddrLabelDiff +enum ZigClangAPValueKind { + ZigClangAPValueNone, + ZigClangAPValueIndeterminate, + ZigClangAPValueInt, + ZigClangAPValueFloat, + ZigClangAPValueFixedPoint, + ZigClangAPValueComplexInt, + ZigClangAPValueComplexFloat, + ZigClangAPValueLValue, + ZigClangAPValueVector, + ZigClangAPValueArray, + ZigClangAPValueStruct, + ZigClangAPValueUnion, + ZigClangAPValueMemberPointer, + ZigClangAPValueAddrLabelDiff, }; struct ZigClangAPValue { - enum ZigClangAPValue_ValueKind Kind; + enum ZigClangAPValueKind Kind; // experimentally-derived size of clang::APValue::DataType #if defined(WIN32) && defined(_MSC_VER) char Data[52]; @@ -214,6 +216,7 @@ enum ZigClangTypeClass { ZigClangType_UnresolvedUsing, ZigClangType_Paren, ZigClangType_Typedef, + ZigClangType_MacroQualified, ZigClangType_Adjusted, ZigClangType_Decayed, ZigClangType_TypeOfExpr, @@ -243,10 +246,9 @@ enum ZigClangTypeClass { }; enum ZigClangStmtClass { - ZigClangStmt_NoStmtClass = 0, + ZigClangStmt_NoStmtClass, ZigClangStmt_GCCAsmStmtClass, ZigClangStmt_MSAsmStmtClass, - ZigClangStmt_AttributedStmtClass, ZigClangStmt_BreakStmtClass, ZigClangStmt_CXXCatchStmtClass, ZigClangStmt_CXXForRangeStmtClass, @@ -258,6 +260,75 @@ enum ZigClangStmtClass { ZigClangStmt_CoroutineBodyStmtClass, ZigClangStmt_DeclStmtClass, ZigClangStmt_DoStmtClass, + ZigClangStmt_ForStmtClass, + ZigClangStmt_GotoStmtClass, + ZigClangStmt_IfStmtClass, + ZigClangStmt_IndirectGotoStmtClass, + ZigClangStmt_MSDependentExistsStmtClass, + ZigClangStmt_NullStmtClass, + ZigClangStmt_OMPAtomicDirectiveClass, + ZigClangStmt_OMPBarrierDirectiveClass, + ZigClangStmt_OMPCancelDirectiveClass, + ZigClangStmt_OMPCancellationPointDirectiveClass, + ZigClangStmt_OMPCriticalDirectiveClass, + ZigClangStmt_OMPFlushDirectiveClass, + ZigClangStmt_OMPDistributeDirectiveClass, + ZigClangStmt_OMPDistributeParallelForDirectiveClass, + ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPDistributeSimdDirectiveClass, + ZigClangStmt_OMPForDirectiveClass, + ZigClangStmt_OMPForSimdDirectiveClass, + ZigClangStmt_OMPParallelForDirectiveClass, + ZigClangStmt_OMPParallelForSimdDirectiveClass, + ZigClangStmt_OMPSimdDirectiveClass, + ZigClangStmt_OMPTargetParallelForSimdDirectiveClass, + ZigClangStmt_OMPTargetSimdDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass, + ZigClangStmt_OMPTaskLoopDirectiveClass, + ZigClangStmt_OMPTaskLoopSimdDirectiveClass, + ZigClangStmt_OMPTeamsDistributeDirectiveClass, + ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass, + ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass, + ZigClangStmt_OMPMasterDirectiveClass, + ZigClangStmt_OMPOrderedDirectiveClass, + ZigClangStmt_OMPParallelDirectiveClass, + ZigClangStmt_OMPParallelSectionsDirectiveClass, + ZigClangStmt_OMPSectionDirectiveClass, + ZigClangStmt_OMPSectionsDirectiveClass, + ZigClangStmt_OMPSingleDirectiveClass, + ZigClangStmt_OMPTargetDataDirectiveClass, + ZigClangStmt_OMPTargetDirectiveClass, + ZigClangStmt_OMPTargetEnterDataDirectiveClass, + ZigClangStmt_OMPTargetExitDataDirectiveClass, + ZigClangStmt_OMPTargetParallelDirectiveClass, + ZigClangStmt_OMPTargetParallelForDirectiveClass, + ZigClangStmt_OMPTargetTeamsDirectiveClass, + ZigClangStmt_OMPTargetUpdateDirectiveClass, + ZigClangStmt_OMPTaskDirectiveClass, + ZigClangStmt_OMPTaskgroupDirectiveClass, + ZigClangStmt_OMPTaskwaitDirectiveClass, + ZigClangStmt_OMPTaskyieldDirectiveClass, + ZigClangStmt_OMPTeamsDirectiveClass, + ZigClangStmt_ObjCAtCatchStmtClass, + ZigClangStmt_ObjCAtFinallyStmtClass, + ZigClangStmt_ObjCAtSynchronizedStmtClass, + ZigClangStmt_ObjCAtThrowStmtClass, + ZigClangStmt_ObjCAtTryStmtClass, + ZigClangStmt_ObjCAutoreleasePoolStmtClass, + ZigClangStmt_ObjCForCollectionStmtClass, + ZigClangStmt_ReturnStmtClass, + ZigClangStmt_SEHExceptStmtClass, + ZigClangStmt_SEHFinallyStmtClass, + ZigClangStmt_SEHLeaveStmtClass, + ZigClangStmt_SEHTryStmtClass, + ZigClangStmt_CaseStmtClass, + ZigClangStmt_DefaultStmtClass, + ZigClangStmt_SwitchStmtClass, + ZigClangStmt_AttributedStmtClass, ZigClangStmt_BinaryConditionalOperatorClass, ZigClangStmt_ConditionalOperatorClass, ZigClangStmt_AddrLabelExprClass, @@ -296,6 +367,7 @@ enum ZigClangStmtClass { ZigClangStmt_CXXMemberCallExprClass, ZigClangStmt_CXXOperatorCallExprClass, ZigClangStmt_UserDefinedLiteralClass, + ZigClangStmt_BuiltinBitCastExprClass, ZigClangStmt_CStyleCastExprClass, ZigClangStmt_CXXFunctionalCastExprClass, ZigClangStmt_CXXConstCastExprClass, @@ -361,6 +433,7 @@ enum ZigClangStmtClass { ZigClangStmt_PseudoObjectExprClass, ZigClangStmt_ShuffleVectorExprClass, ZigClangStmt_SizeOfPackExprClass, + ZigClangStmt_SourceLocExprClass, ZigClangStmt_StmtExprClass, ZigClangStmt_StringLiteralClass, ZigClangStmt_SubstNonTypeTemplateParmExprClass, @@ -370,75 +443,7 @@ enum ZigClangStmtClass { ZigClangStmt_UnaryExprOrTypeTraitExprClass, ZigClangStmt_UnaryOperatorClass, ZigClangStmt_VAArgExprClass, - ZigClangStmt_ForStmtClass, - ZigClangStmt_GotoStmtClass, - ZigClangStmt_IfStmtClass, - ZigClangStmt_IndirectGotoStmtClass, ZigClangStmt_LabelStmtClass, - ZigClangStmt_MSDependentExistsStmtClass, - ZigClangStmt_NullStmtClass, - ZigClangStmt_OMPAtomicDirectiveClass, - ZigClangStmt_OMPBarrierDirectiveClass, - ZigClangStmt_OMPCancelDirectiveClass, - ZigClangStmt_OMPCancellationPointDirectiveClass, - ZigClangStmt_OMPCriticalDirectiveClass, - ZigClangStmt_OMPFlushDirectiveClass, - ZigClangStmt_OMPDistributeDirectiveClass, - ZigClangStmt_OMPDistributeParallelForDirectiveClass, - ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass, - ZigClangStmt_OMPDistributeSimdDirectiveClass, - ZigClangStmt_OMPForDirectiveClass, - ZigClangStmt_OMPForSimdDirectiveClass, - ZigClangStmt_OMPParallelForDirectiveClass, - ZigClangStmt_OMPParallelForSimdDirectiveClass, - ZigClangStmt_OMPSimdDirectiveClass, - ZigClangStmt_OMPTargetParallelForSimdDirectiveClass, - ZigClangStmt_OMPTargetSimdDirectiveClass, - ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass, - ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass, - ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass, - ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass, - ZigClangStmt_OMPTaskLoopDirectiveClass, - ZigClangStmt_OMPTaskLoopSimdDirectiveClass, - ZigClangStmt_OMPTeamsDistributeDirectiveClass, - ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass, - ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass, - ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass, - ZigClangStmt_OMPMasterDirectiveClass, - ZigClangStmt_OMPOrderedDirectiveClass, - ZigClangStmt_OMPParallelDirectiveClass, - ZigClangStmt_OMPParallelSectionsDirectiveClass, - ZigClangStmt_OMPSectionDirectiveClass, - ZigClangStmt_OMPSectionsDirectiveClass, - ZigClangStmt_OMPSingleDirectiveClass, - ZigClangStmt_OMPTargetDataDirectiveClass, - ZigClangStmt_OMPTargetDirectiveClass, - ZigClangStmt_OMPTargetEnterDataDirectiveClass, - ZigClangStmt_OMPTargetExitDataDirectiveClass, - ZigClangStmt_OMPTargetParallelDirectiveClass, - ZigClangStmt_OMPTargetParallelForDirectiveClass, - ZigClangStmt_OMPTargetTeamsDirectiveClass, - ZigClangStmt_OMPTargetUpdateDirectiveClass, - ZigClangStmt_OMPTaskDirectiveClass, - ZigClangStmt_OMPTaskgroupDirectiveClass, - ZigClangStmt_OMPTaskwaitDirectiveClass, - ZigClangStmt_OMPTaskyieldDirectiveClass, - ZigClangStmt_OMPTeamsDirectiveClass, - ZigClangStmt_ObjCAtCatchStmtClass, - ZigClangStmt_ObjCAtFinallyStmtClass, - ZigClangStmt_ObjCAtSynchronizedStmtClass, - ZigClangStmt_ObjCAtThrowStmtClass, - ZigClangStmt_ObjCAtTryStmtClass, - ZigClangStmt_ObjCAutoreleasePoolStmtClass, - ZigClangStmt_ObjCForCollectionStmtClass, - ZigClangStmt_ReturnStmtClass, - ZigClangStmt_SEHExceptStmtClass, - ZigClangStmt_SEHFinallyStmtClass, - ZigClangStmt_SEHLeaveStmtClass, - ZigClangStmt_SEHTryStmtClass, - ZigClangStmt_CaseStmtClass, - ZigClangStmt_DefaultStmtClass, - ZigClangStmt_SwitchStmtClass, ZigClangStmt_WhileStmtClass, }; @@ -446,6 +451,7 @@ enum ZigClangCK { ZigClangCK_Dependent, ZigClangCK_BitCast, ZigClangCK_LValueBitCast, + ZigClangCK_LValueToRValueBitCast, ZigClangCK_LValueToRValue, ZigClangCK_NoOp, ZigClangCK_BaseToDerived, @@ -472,6 +478,8 @@ enum ZigClangCK { ZigClangCK_IntegralToBoolean, ZigClangCK_IntegralToFloating, ZigClangCK_FixedPointCast, + ZigClangCK_FixedPointToIntegral, + ZigClangCK_IntegralToFixedPoint, ZigClangCK_FixedPointToBoolean, ZigClangCK_FloatingToIntegral, ZigClangCK_FloatingToBoolean, @@ -504,21 +512,6 @@ enum ZigClangCK { ZigClangCK_IntToOCLSampler, }; -enum ZigClangAPValueKind { - ZigClangAPValueUninitialized, - ZigClangAPValueInt, - ZigClangAPValueFloat, - ZigClangAPValueComplexInt, - ZigClangAPValueComplexFloat, - ZigClangAPValueLValue, - ZigClangAPValueVector, - ZigClangAPValueArray, - ZigClangAPValueStruct, - ZigClangAPValueUnion, - ZigClangAPValueMemberPointer, - ZigClangAPValueAddrLabelDiff, -}; - enum ZigClangDeclKind { ZigClangDeclAccessSpec, ZigClangDeclBlock, @@ -544,6 +537,7 @@ enum ZigClangDeclKind { ZigClangDeclObjCMethod, ZigClangDeclObjCProperty, ZigClangDeclBuiltinTemplate, + ZigClangDeclConcept, ZigClangDeclClassTemplate, ZigClangDeclFunctionTemplate, ZigClangDeclTypeAliasTemplate, @@ -585,8 +579,10 @@ enum ZigClangDeclKind { ZigClangDeclVarTemplatePartialSpecialization, ZigClangDeclEnumConstant, ZigClangDeclIndirectField, + ZigClangDeclOMPDeclareMapper, ZigClangDeclOMPDeclareReduction, ZigClangDeclUnresolvedUsingValue, + ZigClangDeclOMPAllocate, ZigClangDeclOMPRequires, ZigClangDeclOMPThreadPrivate, ZigClangDeclObjCPropertyImpl,