From 8f92a49dfde5e8690525da028844cb7c1188d397 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 16 Jul 2019 22:23:48 -0400 Subject: update to llvm9 trunk --- src/target.cpp | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/target.cpp') diff --git a/src/target.cpp b/src/target.cpp index 804c421618..1c5a34e54f 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -33,6 +33,7 @@ static const ZigLLVM_SubArchType subarch_list_arm32[] = { ZigLLVM_ARMSubArch_v8r, ZigLLVM_ARMSubArch_v8m_baseline, ZigLLVM_ARMSubArch_v8m_mainline, + ZigLLVM_ARMSubArch_v8_1m_mainline, ZigLLVM_ARMSubArch_v7, ZigLLVM_ARMSubArch_v7em, ZigLLVM_ARMSubArch_v7m, @@ -76,6 +77,7 @@ static const ZigLLVM_ArchType arch_list[] = { ZigLLVM_armeb, // ARM (big endian): armeb ZigLLVM_aarch64, // AArch64 (little endian): aarch64 ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be + ZigLLVM_aarch64_32, // AArch64 (little endian) ILP32: aarch64_32 ZigLLVM_arc, // ARC: Synopsys ARC ZigLLVM_avr, // AVR: Atmel AVR microcontroller ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) @@ -176,6 +178,7 @@ static const Os os_list[] = { OsHermitCore, OsHurd, OsWASI, + OsEmscripten, OsZen, OsUefi, }; @@ -193,15 +196,19 @@ static const ZigLLVM_EnvironmentType abi_list[] = { ZigLLVM_CODE16, ZigLLVM_EABI, ZigLLVM_EABIHF, + ZigLLVM_ELFv1, + ZigLLVM_ELFv2, ZigLLVM_Android, ZigLLVM_Musl, ZigLLVM_MuslEABI, ZigLLVM_MuslEABIHF, + ZigLLVM_MSVC, ZigLLVM_Itanium, ZigLLVM_Cygnus, ZigLLVM_CoreCLR, ZigLLVM_Simulator, + ZigLLVM_MacABI, }; static const ZigLLVM_ObjectFormatType oformat_list[] = { -- cgit v1.2.3 From e816d592e8773c03ca92645d978669ec6de5ca0c Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 17 Jul 2019 17:45:24 -0400 Subject: 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(-) (limited to 'src/target.cpp') 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, -- cgit v1.2.3 From d4ca337e6b8d0c268ebce5c4b5fbe9015f3d8ab6 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 18 Jul 2019 11:45:37 -0400 Subject: improvements to riscv support --- src/codegen.cpp | 18 +++++++++++++++++- src/link.cpp | 6 ++++-- src/target.cpp | 19 ++++++++++++++++++- src/target.hpp | 2 ++ 4 files changed, 41 insertions(+), 4 deletions(-) (limited to 'src/target.cpp') diff --git a/src/codegen.cpp b/src/codegen.cpp index 188c5ccc8d..7136429615 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -8390,13 +8390,13 @@ void add_cc_args(CodeGen *g, ZigList &args, const char *out_dep_pa } } + // According to Rich Felker libc headers are supposed to go before C language headers. for (size_t i = 0; i < g->libc_include_dir_len; i += 1) { Buf *include_dir = g->libc_include_dir_list[i]; args.append("-isystem"); args.append(buf_ptr(include_dir)); } - // According to Rich Felker libc headers are supposed to go before C language headers. args.append("-isystem"); args.append(buf_ptr(g->zig_c_headers_dir)); @@ -8405,6 +8405,21 @@ void add_cc_args(CodeGen *g, ZigList &args, const char *out_dep_pa } else { args.append("-target"); args.append(buf_ptr(&g->llvm_triple_str)); + + if (target_is_musl(g->zig_target) && target_is_riscv(g->zig_target)) { + // Musl depends on atomic instructions, which are disabled by default in Clang/LLVM's + // cross compilation CPU info for RISCV. + switch (g->zig_target->arch) { + case ZigLLVM_riscv32: + args.append("-march=rv32ia"); + break; + case ZigLLVM_riscv64: + args.append("-march=rv64ia"); + break; + default: + zig_unreachable(); + } + } } if (g->zig_target->os == OsFreestanding) { args.append("-ffreestanding"); @@ -8474,6 +8489,7 @@ void add_cc_args(CodeGen *g, ZigList &args, const char *out_dep_pa for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) { args.append(g->clang_argv[arg_i]); } + } void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation) { diff --git a/src/link.cpp b/src/link.cpp index 88267f6cac..a7cb9ad26f 100644 --- a/src/link.cpp +++ b/src/link.cpp @@ -1658,7 +1658,9 @@ static void construct_linker_job_elf(LinkJob *lj) { crt1o = "Scrt1.o"; } lj->args.append(get_libc_crt_file(g, crt1o)); - lj->args.append(get_libc_crt_file(g, "crti.o")); + if (target_libc_needs_crti_crtn(g->zig_target)) { + lj->args.append(get_libc_crt_file(g, "crti.o")); + } } for (size_t i = 0; i < g->rpath_list.length; i += 1) { @@ -1791,7 +1793,7 @@ static void construct_linker_job_elf(LinkJob *lj) { } // crt end - if (lj->link_in_crt) { + if (lj->link_in_crt && target_libc_needs_crti_crtn(g->zig_target)) { lj->args.append(get_libc_crt_file(g, "crtn.o")); } diff --git a/src/target.cpp b/src/target.cpp index fd5deeea29..05eb3c662f 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -1739,8 +1739,25 @@ const char *target_arch_musl_name(ZigLLVM_ArchType arch) { } bool target_supports_libunwind(const ZigTarget *target) { - if (target->arch == ZigLLVM_arm || target->arch == ZigLLVM_armeb) { + switch (target->arch) { + case ZigLLVM_arm: + case ZigLLVM_armeb: + case ZigLLVM_riscv32: + case ZigLLVM_riscv64: + return false; + default: + return true; + } + return true; +} + +bool target_libc_needs_crti_crtn(const ZigTarget *target) { + if (target->arch == ZigLLVM_riscv32 || target->arch == ZigLLVM_riscv64) { return false; } return true; } + +bool target_is_riscv(const ZigTarget *target) { + return target->arch == ZigLLVM_riscv32 || target->arch == ZigLLVM_riscv64; +} diff --git a/src/target.hpp b/src/target.hpp index 85768347a5..a8c0c890eb 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_riscv(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); @@ -197,5 +198,6 @@ uint32_t target_arch_pointer_bit_width(ZigLLVM_ArchType arch); size_t target_libc_count(void); void target_libc_enum(size_t index, ZigTarget *out_target); +bool target_libc_needs_crti_crtn(const ZigTarget *target); #endif -- cgit v1.2.3 From a3854d042e0d05a87ae9f0b71d12474c8d0e57ec Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 18 Jul 2019 15:03:21 -0400 Subject: basic riscv support llvm is giving me `error: couldn't allocate output register for constraint '{a0}'` which is a bug that needs to be fixed upstream. --- src/target.cpp | 4 +- std/os/bits/linux.zig | 1 + std/os/bits/linux/riscv64.zig | 279 ++++++++++++++++++++++++++++++++++++++++++ std/os/linux.zig | 1 + std/os/linux/arm64.zig | 7 ++ std/os/linux/riscv64.zig | 78 ++++++++++++ std/os/linux/tls.zig | 9 +- std/os/linux/x86_64.zig | 14 +-- std/special/start.zig | 5 + 9 files changed, 388 insertions(+), 10 deletions(-) create mode 100644 std/os/bits/linux/riscv64.zig create mode 100644 std/os/linux/riscv64.zig (limited to 'src/target.cpp') diff --git a/src/target.cpp b/src/target.cpp index 05eb3c662f..5a418aa547 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -1320,6 +1320,8 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) { case ZigLLVM_aarch64: case ZigLLVM_aarch64_be: case ZigLLVM_aarch64_32: + case ZigLLVM_riscv32: + case ZigLLVM_riscv64: return "sp"; case ZigLLVM_arm: @@ -1350,8 +1352,6 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) { case ZigLLVM_r600: case ZigLLVM_renderscript32: case ZigLLVM_renderscript64: - case ZigLLVM_riscv32: - case ZigLLVM_riscv64: case ZigLLVM_shave: case ZigLLVM_sparc: case ZigLLVM_sparcel: diff --git a/std/os/bits/linux.zig b/std/os/bits/linux.zig index 8430a05bf0..d7c23ffadb 100644 --- a/std/os/bits/linux.zig +++ b/std/os/bits/linux.zig @@ -7,6 +7,7 @@ pub usingnamespace @import("linux/errno.zig"); pub usingnamespace switch (builtin.arch) { .x86_64 => @import("linux/x86_64.zig"), .aarch64 => @import("linux/arm64.zig"), + .riscv64 => @import("linux/riscv64.zig"), else => struct {}, }; diff --git a/std/os/bits/linux/riscv64.zig b/std/os/bits/linux/riscv64.zig new file mode 100644 index 0000000000..cb3124792d --- /dev/null +++ b/std/os/bits/linux/riscv64.zig @@ -0,0 +1,279 @@ +// riscv64-specific declarations that are intended to be imported into the POSIX namespace. + +pub const SYS_io_setup = 0; +pub const SYS_io_destroy = 1; +pub const SYS_io_submit = 2; +pub const SYS_io_cancel = 3; +pub const SYS_io_getevents = 4; +pub const SYS_setxattr = 5; +pub const SYS_lsetxattr = 6; +pub const SYS_fsetxattr = 7; +pub const SYS_getxattr = 8; +pub const SYS_lgetxattr = 9; +pub const SYS_fgetxattr = 10; +pub const SYS_listxattr = 11; +pub const SYS_llistxattr = 12; +pub const SYS_flistxattr = 13; +pub const SYS_removexattr = 14; +pub const SYS_lremovexattr = 15; +pub const SYS_fremovexattr = 16; +pub const SYS_getcwd = 17; +pub const SYS_lookup_dcookie = 18; +pub const SYS_eventfd2 = 19; +pub const SYS_epoll_create1 = 20; +pub const SYS_epoll_ctl = 21; +pub const SYS_epoll_pwait = 22; +pub const SYS_dup = 23; +pub const SYS_dup3 = 24; +pub const SYS_fcntl = 25; +pub const SYS_inotify_init1 = 26; +pub const SYS_inotify_add_watch = 27; +pub const SYS_inotify_rm_watch = 28; +pub const SYS_ioctl = 29; +pub const SYS_ioprio_set = 30; +pub const SYS_ioprio_get = 31; +pub const SYS_flock = 32; +pub const SYS_mknodat = 33; +pub const SYS_mkdirat = 34; +pub const SYS_unlinkat = 35; +pub const SYS_symlinkat = 36; +pub const SYS_linkat = 37; +pub const SYS_umount2 = 39; +pub const SYS_mount = 40; +pub const SYS_pivot_root = 41; +pub const SYS_nfsservctl = 42; +pub const SYS_statfs = 43; +pub const SYS_fstatfs = 44; +pub const SYS_truncate = 45; +pub const SYS_ftruncate = 46; +pub const SYS_fallocate = 47; +pub const SYS_faccessat = 48; +pub const SYS_chdir = 49; +pub const SYS_fchdir = 50; +pub const SYS_chroot = 51; +pub const SYS_fchmod = 52; +pub const SYS_fchmodat = 53; +pub const SYS_fchownat = 54; +pub const SYS_fchown = 55; +pub const SYS_openat = 56; +pub const SYS_close = 57; +pub const SYS_vhangup = 58; +pub const SYS_pipe2 = 59; +pub const SYS_quotactl = 60; +pub const SYS_getdents64 = 61; +pub const SYS_lseek = 62; +pub const SYS_read = 63; +pub const SYS_write = 64; +pub const SYS_readv = 65; +pub const SYS_writev = 66; +pub const SYS_pread64 = 67; +pub const SYS_pwrite64 = 68; +pub const SYS_preadv = 69; +pub const SYS_pwritev = 70; +pub const SYS_sendfile = 71; +pub const SYS_pselect6 = 72; +pub const SYS_ppoll = 73; +pub const SYS_signalfd4 = 74; +pub const SYS_vmsplice = 75; +pub const SYS_splice = 76; +pub const SYS_tee = 77; +pub const SYS_readlinkat = 78; +pub const SYS_fstatat = 79; +pub const SYS_fstat = 80; +pub const SYS_sync = 81; +pub const SYS_fsync = 82; +pub const SYS_fdatasync = 83; +pub const SYS_sync_file_range = 84; +pub const SYS_timerfd_create = 85; +pub const SYS_timerfd_settime = 86; +pub const SYS_timerfd_gettime = 87; +pub const SYS_utimensat = 88; +pub const SYS_acct = 89; +pub const SYS_capget = 90; +pub const SYS_capset = 91; +pub const SYS_personality = 92; +pub const SYS_exit = 93; +pub const SYS_exit_group = 94; +pub const SYS_waitid = 95; +pub const SYS_set_tid_address = 96; +pub const SYS_unshare = 97; +pub const SYS_futex = 98; +pub const SYS_set_robust_list = 99; +pub const SYS_get_robust_list = 100; +pub const SYS_nanosleep = 101; +pub const SYS_getitimer = 102; +pub const SYS_setitimer = 103; +pub const SYS_kexec_load = 104; +pub const SYS_init_module = 105; +pub const SYS_delete_module = 106; +pub const SYS_timer_create = 107; +pub const SYS_timer_gettime = 108; +pub const SYS_timer_getoverrun = 109; +pub const SYS_timer_settime = 110; +pub const SYS_timer_delete = 111; +pub const SYS_clock_settime = 112; +pub const SYS_clock_gettime = 113; +pub const SYS_clock_getres = 114; +pub const SYS_clock_nanosleep = 115; +pub const SYS_syslog = 116; +pub const SYS_ptrace = 117; +pub const SYS_sched_setparam = 118; +pub const SYS_sched_setscheduler = 119; +pub const SYS_sched_getscheduler = 120; +pub const SYS_sched_getparam = 121; +pub const SYS_sched_setaffinity = 122; +pub const SYS_sched_getaffinity = 123; +pub const SYS_sched_yield = 124; +pub const SYS_sched_get_priority_max = 125; +pub const SYS_sched_get_priority_min = 126; +pub const SYS_sched_rr_get_interval = 127; +pub const SYS_restart_syscall = 128; +pub const SYS_kill = 129; +pub const SYS_tkill = 130; +pub const SYS_tgkill = 131; +pub const SYS_sigaltstack = 132; +pub const SYS_rt_sigsuspend = 133; +pub const SYS_rt_sigaction = 134; +pub const SYS_rt_sigprocmask = 135; +pub const SYS_rt_sigpending = 136; +pub const SYS_rt_sigtimedwait = 137; +pub const SYS_rt_sigqueueinfo = 138; +pub const SYS_rt_sigreturn = 139; +pub const SYS_setpriority = 140; +pub const SYS_getpriority = 141; +pub const SYS_reboot = 142; +pub const SYS_setregid = 143; +pub const SYS_setgid = 144; +pub const SYS_setreuid = 145; +pub const SYS_setuid = 146; +pub const SYS_setresuid = 147; +pub const SYS_getresuid = 148; +pub const SYS_setresgid = 149; +pub const SYS_getresgid = 150; +pub const SYS_setfsuid = 151; +pub const SYS_setfsgid = 152; +pub const SYS_times = 153; +pub const SYS_setpgid = 154; +pub const SYS_getpgid = 155; +pub const SYS_getsid = 156; +pub const SYS_setsid = 157; +pub const SYS_getgroups = 158; +pub const SYS_setgroups = 159; +pub const SYS_uname = 160; +pub const SYS_sethostname = 161; +pub const SYS_setdomainname = 162; +pub const SYS_getrlimit = 163; +pub const SYS_setrlimit = 164; +pub const SYS_getrusage = 165; +pub const SYS_umask = 166; +pub const SYS_prctl = 167; +pub const SYS_getcpu = 168; +pub const SYS_gettimeofday = 169; +pub const SYS_settimeofday = 170; +pub const SYS_adjtimex = 171; +pub const SYS_getpid = 172; +pub const SYS_getppid = 173; +pub const SYS_getuid = 174; +pub const SYS_geteuid = 175; +pub const SYS_getgid = 176; +pub const SYS_getegid = 177; +pub const SYS_gettid = 178; +pub const SYS_sysinfo = 179; +pub const SYS_mq_open = 180; +pub const SYS_mq_unlink = 181; +pub const SYS_mq_timedsend = 182; +pub const SYS_mq_timedreceive = 183; +pub const SYS_mq_notify = 184; +pub const SYS_mq_getsetattr = 185; +pub const SYS_msgget = 186; +pub const SYS_msgctl = 187; +pub const SYS_msgrcv = 188; +pub const SYS_msgsnd = 189; +pub const SYS_semget = 190; +pub const SYS_semctl = 191; +pub const SYS_semtimedop = 192; +pub const SYS_semop = 193; +pub const SYS_shmget = 194; +pub const SYS_shmctl = 195; +pub const SYS_shmat = 196; +pub const SYS_shmdt = 197; +pub const SYS_socket = 198; +pub const SYS_socketpair = 199; +pub const SYS_bind = 200; +pub const SYS_listen = 201; +pub const SYS_accept = 202; +pub const SYS_connect = 203; +pub const SYS_getsockname = 204; +pub const SYS_getpeername = 205; +pub const SYS_sendto = 206; +pub const SYS_recvfrom = 207; +pub const SYS_setsockopt = 208; +pub const SYS_getsockopt = 209; +pub const SYS_shutdown = 210; +pub const SYS_sendmsg = 211; +pub const SYS_recvmsg = 212; +pub const SYS_readahead = 213; +pub const SYS_brk = 214; +pub const SYS_munmap = 215; +pub const SYS_mremap = 216; +pub const SYS_add_key = 217; +pub const SYS_request_key = 218; +pub const SYS_keyctl = 219; +pub const SYS_clone = 220; +pub const SYS_execve = 221; +pub const SYS_mmap = 222; +pub const SYS_fadvise64 = 223; +pub const SYS_swapon = 224; +pub const SYS_swapoff = 225; +pub const SYS_mprotect = 226; +pub const SYS_msync = 227; +pub const SYS_mlock = 228; +pub const SYS_munlock = 229; +pub const SYS_mlockall = 230; +pub const SYS_munlockall = 231; +pub const SYS_mincore = 232; +pub const SYS_madvise = 233; +pub const SYS_remap_file_pages = 234; +pub const SYS_mbind = 235; +pub const SYS_get_mempolicy = 236; +pub const SYS_set_mempolicy = 237; +pub const SYS_migrate_pages = 238; +pub const SYS_move_pages = 239; +pub const SYS_rt_tgsigqueueinfo = 240; +pub const SYS_perf_event_open = 241; +pub const SYS_accept4 = 242; +pub const SYS_recvmmsg = 243; +pub const SYS_arch_specific_syscall = 244; +pub const SYS_wait4 = 260; +pub const SYS_prlimit64 = 261; +pub const SYS_fanotify_init = 262; +pub const SYS_fanotify_mark = 263; +pub const SYS_name_to_handle_at = 264; +pub const SYS_open_by_handle_at = 265; +pub const SYS_clock_adjtime = 266; +pub const SYS_syncfs = 267; +pub const SYS_setns = 268; +pub const SYS_sendmmsg = 269; +pub const SYS_process_vm_readv = 270; +pub const SYS_process_vm_writev = 271; +pub const SYS_kcmp = 272; +pub const SYS_finit_module = 273; +pub const SYS_sched_setattr = 274; +pub const SYS_sched_getattr = 275; +pub const SYS_renameat2 = 276; +pub const SYS_seccomp = 277; +pub const SYS_getrandom = 278; +pub const SYS_memfd_create = 279; +pub const SYS_bpf = 280; +pub const SYS_execveat = 281; +pub const SYS_userfaultfd = 282; +pub const SYS_membarrier = 283; +pub const SYS_mlock2 = 284; +pub const SYS_copy_file_range = 285; +pub const SYS_preadv2 = 286; +pub const SYS_pwritev2 = 287; +pub const SYS_pkey_mprotect = 288; +pub const SYS_pkey_alloc = 289; +pub const SYS_pkey_free = 290; +pub const SYS_sysriscv = 244; +pub const SYS_riscv_flush_icache = SYS_sysriscv + 15; diff --git a/std/os/linux.zig b/std/os/linux.zig index 053f30d265..e217430e27 100644 --- a/std/os/linux.zig +++ b/std/os/linux.zig @@ -17,6 +17,7 @@ pub const is_the_target = builtin.os == .linux; pub usingnamespace switch (builtin.arch) { .x86_64 => @import("linux/x86_64.zig"), .aarch64 => @import("linux/arm64.zig"), + .riscv64 => @import("linux/riscv64.zig"), else => struct {}, }; pub usingnamespace @import("bits.zig"); diff --git a/std/os/linux/arm64.zig b/std/os/linux/arm64.zig index 94cf8818de..f50374a503 100644 --- a/std/os/linux/arm64.zig +++ b/std/os/linux/arm64.zig @@ -2,6 +2,7 @@ pub fn syscall0(number: usize) usize { return asm volatile ("svc #0" : [ret] "={x0}" (-> usize) : [number] "{x8}" (number) + : "memory" ); } @@ -10,6 +11,7 @@ pub fn syscall1(number: usize, arg1: usize) usize { : [ret] "={x0}" (-> usize) : [number] "{x8}" (number), [arg1] "{x0}" (arg1) + : "memory" ); } @@ -19,6 +21,7 @@ pub fn syscall2(number: usize, arg1: usize, arg2: usize) usize { : [number] "{x8}" (number), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2) + : "memory" ); } @@ -29,6 +32,7 @@ pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize { [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3) + : "memory" ); } @@ -40,6 +44,7 @@ pub fn syscall4(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usiz [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), [arg4] "{x3}" (arg4) + : "memory" ); } @@ -52,6 +57,7 @@ pub fn syscall5(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usiz [arg3] "{x2}" (arg3), [arg4] "{x3}" (arg4), [arg5] "{x4}" (arg5) + : "memory" ); } @@ -73,6 +79,7 @@ pub fn syscall6( [arg4] "{x3}" (arg4), [arg5] "{x4}" (arg5), [arg6] "{x5}" (arg6) + : "memory" ); } diff --git a/std/os/linux/riscv64.zig b/std/os/linux/riscv64.zig new file mode 100644 index 0000000000..b9264aa3db --- /dev/null +++ b/std/os/linux/riscv64.zig @@ -0,0 +1,78 @@ +pub fn syscall0(number: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number) + : "memory" + ); +} + +pub fn syscall1(number: usize, arg1: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1) + ); +} + +pub fn syscall2(number: usize, arg1: usize, arg2: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1), + [arg2] "{a1}" (arg2) + ); +} + +pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1), + [arg2] "{a1}" (arg2), + [arg3] "{a2}" (arg3) + ); +} + +pub fn syscall4(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1), + [arg2] "{a1}" (arg2), + [arg3] "{a2}" (arg3), + [arg4] "{a3}" (arg4) + ); +} + +pub fn syscall5(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1), + [arg2] "{a1}" (arg2), + [arg3] "{a2}" (arg3), + [arg4] "{a3}" (arg4), + [arg5] "{a4}" (arg5) + ); +} + +pub fn syscall6( + number: usize, + arg1: usize, + arg2: usize, + arg3: usize, + arg4: usize, + arg5: usize, + arg6: usize, +) usize { + return asm volatile ("ecall" + : [ret] "={a0}" (-> usize) + : [number] "{a7}" (number), + [arg1] "{a0}" (arg1), + [arg2] "{a1}" (arg2), + [arg3] "{a2}" (arg3), + [arg4] "{a3}" (arg4), + [arg5] "{a4}" (arg5), + [arg6] "{a5}" (arg6) + ); +} diff --git a/std/os/linux/tls.zig b/std/os/linux/tls.zig index a10d68663b..4996065121 100644 --- a/std/os/linux/tls.zig +++ b/std/os/linux/tls.zig @@ -47,7 +47,7 @@ const TLSVariant = enum { }; const tls_variant = switch (builtin.arch) { - .arm, .armeb, .aarch64, .aarch64_be => TLSVariant.VariantI, + .arm, .armeb, .aarch64, .aarch64_be, .riscv32, .riscv64 => TLSVariant.VariantI, .x86_64, .i386 => TLSVariant.VariantII, else => @compileError("undefined tls_variant for this architecture"), }; @@ -118,6 +118,13 @@ pub fn setThreadPointer(addr: usize) void { : [addr] "r" (addr) ); }, + .riscv64 => { + asm volatile ( + \\ mv tp, %[addr] + : + : [addr] "r" (addr) + ); + }, else => @compileError("Unsupported architecture"), } } diff --git a/std/os/linux/x86_64.zig b/std/os/linux/x86_64.zig index 82eed0256b..0f3a36636a 100644 --- a/std/os/linux/x86_64.zig +++ b/std/os/linux/x86_64.zig @@ -4,7 +4,7 @@ pub fn syscall0(number: usize) usize { return asm volatile ("syscall" : [ret] "={rax}" (-> usize) : [number] "{rax}" (number) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -13,7 +13,7 @@ pub fn syscall1(number: usize, arg1: usize) usize { : [ret] "={rax}" (-> usize) : [number] "{rax}" (number), [arg1] "{rdi}" (arg1) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -23,7 +23,7 @@ pub fn syscall2(number: usize, arg1: usize, arg2: usize) usize { : [number] "{rax}" (number), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -34,7 +34,7 @@ pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize { [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -46,7 +46,7 @@ pub fn syscall4(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usiz [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), [arg4] "{r10}" (arg4) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -59,7 +59,7 @@ pub fn syscall5(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usiz [arg3] "{rdx}" (arg3), [arg4] "{r10}" (arg4), [arg5] "{r8}" (arg5) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } @@ -81,7 +81,7 @@ pub fn syscall6( [arg4] "{r10}" (arg4), [arg5] "{r8}" (arg5), [arg6] "{r9}" (arg6) - : "rcx", "r11" + : "rcx", "r11", "memory" ); } diff --git a/std/special/start.zig b/std/special/start.zig index 30298669e3..42dda53121 100644 --- a/std/special/start.zig +++ b/std/special/start.zig @@ -59,6 +59,11 @@ nakedcc fn _start() noreturn { : [argc] "=r" (-> [*]usize) ); }, + .riscv64 => { + argc_ptr = asm ("mov %[argc], sp" + : [argc] "=r" (-> [*]usize) + ); + }, else => @compileError("unsupported arch"), } // If LLVM inlines stack variables into _start, they will overwrite -- cgit v1.2.3 From c39bb3ebc49096af45f3a69d4742e5f4d50cab62 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 16 Aug 2019 16:52:45 -0400 Subject: target: add missing switch case --- src/target.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/target.cpp') diff --git a/src/target.cpp b/src/target.cpp index 346772ce13..8b533f4af6 100644 --- a/src/target.cpp +++ b/src/target.cpp @@ -686,6 +686,8 @@ const char *target_subarch_name(ZigLLVM_SubArchType subarch) { return "v8m_baseline"; case ZigLLVM_ARMSubArch_v8m_mainline: return "v8m_mainline"; + case ZigLLVM_ARMSubArch_v8_1m_mainline: + return "v8_1m_mainline"; case ZigLLVM_ARMSubArch_v7: return "v7"; case ZigLLVM_ARMSubArch_v7em: -- cgit v1.2.3