Llvm20 #237
Merged
Llvm20 #237
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
* XFER to machine
* Begin uodates to LibLLVM to support LLVM20
* A lot has changed in 10 major releases and this is only the beginning
* Native DLL building
* Native DLL now builds for Win64 but managed code fails for a variety of reasons.
* Fixed minor typo in Targetframework for a sample
* Removed XML docs files
* Support for this was flaky, at best and very tedious.
- It was also unnecessary as the interop isn't intnded for direct use.
* First compilation of new Interop library (untested)
* Generated source files then hand edited to support AOT sceanarios
* Moved generated files into AOT as generation "seemed like a good idea at the time"
- Ultimately it makes a mess of things and ends up with the marshalling information etc... in a custom language
- (See also: #214)
- Too much has changed in >ENT AOT and in LLVM to make it worth trying to generalize the code generation and instead rely on the language itself and source generators.
* source generators are REALLY useful for the "handle" types as there are a lot of them and implementing them is just tedious.
* Removed sourceGen for handles
* While the cod did finlally work, it ran into the problem of source generator ordering.
- LibraryImportAttribute uses a Source generator that needs to see the whole type to get the `NativeMarshaller` attribute to know how to marshal the type. However, that is ONLY provided by the handle source generator. Thus for things to work. There would need to be some sort of guaranteed ordering of generators, which does not exist at present. (That's a sadly VERY complicated issue in general. [see: dotnet/roslyn#57239])
* Applied code cleanup to ALL of the managed interop code base.
* General cleanup of interop in prep for building the next layer
* Final version of LlvmBindingsGenerator
- Any updates to interop code is done manually from now on. It's too much of a PITA to maintain a generalized source generator that uses a distinct language to represent what is representable in the target language already.
- If new APIs are needed, then they can be added easily enough.
- Down side is if APIs are removed entirely or if the signature changes there's no "net" to catch them...
- Something may be slvageable from the current generator and an processor of the IL metadata files (Cecil?) to detect any mis-alignements...
* Manual overhaul of "generated code" that is no longer generated
- It was getting tedious to figure out how to generalize all of the handling of interop
- It is now expressed entirely in C# as it always should have
- splitting the handles and using SourceGen can simplify things even further
* Minor typo fix
* Editor config updates
* Updated interop support to leverate source generation.
- LlvmBindings generator is now reduced to supporting only basic validations of the input headers and generation of the EXPORTS.g.def
- Even that may be removed if the LLVM library is converted to building a DLL for windows or a shared library for non-windows platforms. instead of a bunch of static libs and debug symbols etc...
- Doing that is left for another day...
* Removed "handles" namespace as it makes consumption a LOT more work
- Intention is that the handles library is one in the same as the interop library but they are distinct ONLY for the purpose of resolving the source generator ordering in a deterministic manner.
* Removed use of Roslyn Generator...
- Lots of back and forth on that but, in the end it just wasn't a right fit for this scenario. (See varios readme.md files for the gory details)
* Updates to global build needed
* Massive re-work of the OO, and interop layers to compile.
- No testing done yet, and anything that depends on the compiling layers is not yet updated or tested.
- At least it compiles now!
- There are several places where things were simply removed. Especially regarding the legay PassManager as that all needs some major work to support the newer pass builder concetps etc...
* Adding missed but required functionality to get the name of an attribute as a string from it's ID.
- This is implemented as an extension API to leverage existing functionality.
* First build for LLVM20 with all tests passing and `CodeGenWithDebugInfo` sample generating code!
* Updates to support testing and code generation
- Everything up to but not incliding optimization and JIT
- Both optimization pass management and JIT have changed significantly since LLVM 10 and still needs some work
* Set interop lib to AOT compatible and fixed an AOT related bug
* Additional marking component libraries as AOT compatible
* Refactoring layers
* Adjusted all string marshalling (except p/Invokes) to use Encoding based marshalling to ensure correct behavior x-plat.
- P/Invokes will come as a large single commit as there's a LOT to change
- Added tests for string marshalling behavior.
* Converted some properties to provide string.Empty instead of null
- Tests were validating that it was sometimes null even though it is marked as not nullable!
* Added some lower level support for JIT
- THis is hardly close to complete but encountered issues with string marshalling and envoding so went back to deal with that.
* Large replace to force use of `ExecutionEncodingStringMarshaller` for ALL string marshaling.
- The LLVM docs are silent on the encoding so this forces it all through a single marshaller that leverages an encoding (Currently assumes UTF8, but if there is an error in that assumption there is ONLY one place to fix it now)
- Fixed bug in zero termination of marshalled strings using stateful marshaller
* Test refactoring
* Updated Tests to test for exceptions directly instead of using a custom attribute
* Updated dependencies on ArgValidators to require expclicit refs so things build and run as expected
- Long term goal is to eliminate that completely as the BCL now contains enough support to make most of it obsolete.
* Removed use of Ubiquity.NET.ArgValidators for grammar, parser and at least Chapter 3 sample.
- Also removed it from Interop lib as it was not used there.
- Updated OO wrapper to set it as a private asset as the dependency is an internal implementation detail about to change.
* Updated package references to limit use of the ArgValidators library.
- Slowly removing it as a dependency for any project.
* Removed last dependency on Ubiquity.NET.ArgValidators
- Ubiquity.NET.Llvm had the remaining dependency
- removed all need in favor of standard arg checks with a few extensions for "Fluent" style use.
* Multiple string handling refactorings
* Moved ThrowIfInvalid on generated global handles to an extension method for greater flexibility and fluent support.
* Changed signature of several interop functions to accept a `byte*` as the input to allow use of pre-existing native strings and `LazyEncodedString`
- TODO: Support interop string handles too! ]At least internally]
- The idea is to allow for no marshalling if round tripping strings.
* Added Kaleidoscope Chapter 3.5
* Added optimizations as a distinct sample to allow testing the optimizations independently from JIT support.
* Minor doc updates/corrections
* Moved PassBuilder extension APIs header into proper place so that the tooling will see it and generate the correct exports.def for it.
* Moved a lot of types to generalized Interop helpers library as they are NOT specific to LLVM.
- Updated string handling to eliminate need of both `LazyEncodedString` and `LazyInitializedString` They were too general and ended up with too much complexity.
* Minor typos and refactorings
* Removed all unused namespace "using" statements
* Moved LibLLVM extension types into their own static classes
* This starts the work of moving all the P/Invoke into distinct classes.
- Building and using the Interop library just takes too much resources as the compiler has to keep all source in memory to create the merged final form of the "one" monster `NativeMethods` type.
* Moving additional code into common interop support that is NOT dependent on LLVM
* Moved interop related projects into new "Interop" solution folder to help clarify and make maintenance easier.
* Minor refactorings
* Moved DelegateHolder into the InteropHelpers library as it is NOT LLVM dependent but supports interop in general
* Added implicit conversion from a string to a LazyEncodedString so for greater compatibility with existing code.
- Though for even greater efficiency the calling code should convert to use LazyEncoded string for anything that might go to native code.
* Simplified JIT support
* Tjis does not complete the JIT support but does set patterns to follow for that support.
* Added `InternalsVisibleTo` so that the JIT library can access internals of the LLVM library.
- This is an efficiency/simplification of use issue. It is NOT a security issue.
* Simplified `ExecutionSession` methods to leverage LazyEncodedString for string input
* Updated `ExecutionSession` callback to use internal constructor of `ErrorInfo`
* Massive refactoring of namespaces and usings
* Applied C# global usings to simplify the interop and projection library files greatly.
* Moved all the P/Invoke APIs into their own classes
- This significantly improves the build as it no longer needs to wait for ALL the files to parse before it can run the source generator or merge the members into one Giant type...
* Made Nuget package generation a Release only property so that it is not generated for debug "inner loop" developer builds.
* First working JIT (Including VERY LAZY JIT!) YEAH!
* This does not yet support or include the tutorials adapting those comes next.
* Simplified JIT custom materializer use
* Moved custom materializer type to internal
* Changed Destry delegate to an IDisposable that is ALWAYs called on materialization completion.
- This simplifies things a lot while allowing for disposable resources to be disposed of as early as possible.
* Moved SafeGCHandle to interop helpers so it is usable for other cases.
* This is still an inherently "unsafe" type
- used correctly makes things more safe.
- used incorrectly will likely lead to leaks or crashes.
* Added DiagnosticSeverity filtering to a context to allow filtering
- This whole mechanism should change to allow a caller provided instance of a handler that is then registered with native code. This would allow removal of the caches and interning overhead which would allow most, if not all, of the wrapped OO types to become ref struct with IEquatable<T> support. (Sadly as of .NET 8, T is not allowed to be a ref struct so that transition might need to wait until .NET 9/10)
* Misc. minor updates
* Marked InteropHelpers as AOT compatible
* Added comparison operators to size_t for correctness and to silence warnings.
* Removed use of DelegateHodler as that's problematic for AOT.
- It requires runtime reflection and code generation to build the native callable "thunk" piece. This is an areay where a source generator might work better but needs to consider how a "context" for the delegate is retained while still supporting native APIs that may or may not have an aplication defined 'context' parameter.
* Made PassBuilderOptions a `ref struct`
* This is the general pattern to follow for all of the OO wrapper library.
- As of .NET 8 creating IEquatable<T> doesn't support `allow ref struct`. (.NET 9+ does, but that is not LTS). Full conversion and removal of the "caching" requires support for that.
* First working Kaleidoscope with functioning JIT!
* Added support for transforms to JIT support
* KlsJIT now uses a transform layer to set the module data layout and perform optimizations.
* Updated JIT/optimization support
* Updated chapter 3.5 to use per module passes with default "O3" pipeline
* Adjusted show results to simply provide the result value
* Code cleanup on Chapter 4
- It is not possible to catch/handle a stack overflow from native code (or even managed code) so just let it crash...
* Moved optimizations passes to a constructor paramenter for `KaleidoscopeJIT` with default using 'O3'
* Misc. minor typos and format cleanups
* Missed code cleanup (Formating)
* Added generalized custom diagnostic handler to Context.
* This is the start of transitionaling to record struct for wrapped handles.
- Such transition includes removal of all interning and using value equality `IEquality<>` instead.
* This removes a TON of complexity and overhead from the code AND enables better use with the new ThreadSafexxx support in OrcJIT v2 as disposal becomes an issue if the managed cached value is disposed but the REAL LLVMxxxRef is NOT.
* Converted all projects to use .NET 9
* It is necessary to properly support ref structs, returns etx to also support the `allows ref struct` generic 'anti-constraint` which is sadly only available in .NET 9
- Upgrade to LTS .NET 10 will have to happen later.
* Missed on - updated chapter3.5 to use .NET 9
* Massive re-work to eliminate reference equality.
* Reference equality seems like a good idea but adds a LOT of extra code/complexity to cache managed instances. Additionally, and this is the dirving factor for this shift is that it doesn't work in the face of ThreadSafe constructs used in ORC JIT v2. In particular if a context is relaized from the cache as owned or an alias is LOST as there is only one instance in the cache. Thus the ownership semantics are lost and things go south (access violations) when the cached value that shouldn't be disposed is.
* Added working Chapter 6 [User Defined Operators]
* Updated to add chapter 7
* Added Chapter 7.1 [Very Lazy JIT]
* Preformed solution wide removal of unused "using" statements.
* Updated to suport Chapter 8
* Some minor refactoring of names across the board
* Added module verification to all chapters so any issues with module generation are caught as early as possible with the sample tests
* Updated to support Chapter 9
* This necessitated updates to the Kaleidoscope runtim AST support to handle passing through a DIBuilder instance
* Marked "leaf" instruction types as 'sealed'
* Updated to use platofr/RID independent native library loading
* The interop and all dependnts should now be independent of the runtime environment.
- Though `win-x64` is currently the only supported target this change makes that a matter of the native code NuGet Package, it just needs a build of the correct RID binaries and the managed code will find it.
- For true platform independent targetting the build scripts will need updating as they currently use aliases that may or may not exist on a given platform. (There's quite a raging debate on how PowerShell should/Should not handle that!) Bottom line is that scripts should NOT use aliases or explicitly define them all with scoping for the script only.
* General code cleanup, formal docs update, and build script updates
* Several warnings from analyzers and docs suppressed or fixed
* Updated build scripts to use docfx tool instead of legacy (no longer supported) `docfxconsole`
* Minor project updates
* Updated projects to enable Nuget Packag analysis
* Removed use of `StyleCop.Analyzers` as it seems defunct and not supported anymore.
- Last official release was 2019, last preview was in 2023...
* Re-organized docs build
* Now only uses a single docfx.json This simplifies the build but still allows the main index with legacy docs links.
* Docs cleanup and removed unused "props" from package
- Most of the package props were simply to provide a location, but that's now a part of msbuild package references so no need.
* Minor refactorings for doc updates
* Renamed the LlvmMetadata type so it is 'IrMetadata' to eliminate the redundancy in the name.
- Sadly can't get rid of the "prefix" due to other rules... but this is the best that can be done.
* Converted REPL to use IAsyncEnumerable support
* Added standard cancelation via Ctrl-C handler
* Updated docs readme
* Moved JIT support into the main library
* This incorporates JIT back into the main library and reduces the number of pacakges needed to use the libraries
- This was split out in the past to handle problems with the VERY lazy JIT support on Windows and the ORC JIT engine. Conversion and stabilization of ORC JIT v2 has dramatically improved things to where lazy evaluation is easily accomplished, even on Windows...
* Refactorings for IDisposable
* Cleaned up/clarified/suppressed warnings regarding onwership transfer or aliases for IDisposable types.
* Removed use of Disposable types for property returns as ownership semantics are unclear.
* General code cleanup
* Corrected/clarified doc comments and article content
* Removed uneccessary using imports.
* Added ServeDocs to Build-Docs.ps1 script to allow direct serving of the docs already built. (Either previously with this script or via the Build-all.ps1 script.)
* Refactored string marshalling for LLVMDisposeMessage
* While it may have seemed like a good idea to support lazy marshalling of an LLVM string it turns out to be a MAJOR PITA that complicates code. The only thing done was to manage the IDisposable
nature and then convert to a string. Same as marshalling direct to a string. So this punts the wrapping in favor of the simpler to use marshalling directly at the interop call.
* General docs and string handling imrpovements
* Better support for keeping native strings as UTF8 in ReadOnlySpan<byte> or byte[] for reduced overhead costs of marshalling
* General Refactorings
* Sample clarification and refactoring for ABI specific details
* Simplified Materialization unit symbol name entry support with dictionaries.
* More refactorings and cleanup
* Removed redundant LibLLVM functions where a standard LLVM-C API exists.
* Migrated to requiring target selection at time of Library init.
- This begins to pave the way for support of ONLY two targets, native and one more.
- This allows building the native interop DLL as only supporting two targets, the native runtime (normal for JIT use and no-xplat) and ONE other target. The idea is that this would reduce the time and size constraints for building the library so that it is possible to do in an OSS automated form. (Fingers crossed!)
* Fixed bug in sample code generators where the tracked resources were NOT cleaned up, this caused a random crash if the finalizer kicked in after the JIT etc... was already disposed.
* Added support for MustUseReturnValue
* General update
* Updated build scripts to remove annoying progress bar for remove-item
- At some point a progress bar was added as a default so now it has to be disabled (ugh...)
* Split out re-usable portions of Kaleidoscope support
- This sets the stage for additional libraries that provide better DSL interpreter/runtime support.
- Necessitated hardening of error handling in AST production as ErrorNode is NOT an IExpression (That's a strictly language specific concept not related to general re-use)
- General AST visitor AND language specific forms supported.
* Generalized .NET extensions refactoring
* This pulls most of the general functionality/extensions into a unique library
- The general idea is that everything else has a distinct purpose and remains focused on that. These generally re-usuable support extensions/utility types and methods are standalone and MUST not depends on any of the other libraries (It may be a dependency of ANY [or all] of them)
* Project file packaging updates
* Docs fix to reolve build warnings
* Docs layout update
* Updated docs layout to account for future additions of other library 'API"
- 'api' folder is no longer used, instead a per-pacakge folder is used.
- At present that is only `api-llvm` for the same content as before but this sets the pattern/plan for the other packages.
* refactored `SourcwSpan` to `SourceLocation` to more accurately reflect that it is NOT like `Span<T> or ReadOnlySpan<T>` It only describes the location of text without any reference to the text.
* Cleaned up uneccessary usings from refactoring
* Optimized ORCJit symbol support by providing a `KvpBuilder<TKey, TValue>` to build immutable data
* This avoids the overhead of allocating space for and computing the hash code when it is always ignored and only `IReadOnlyCollection<KeyValuePair<TKey, TValue>>` is used.
* Fixed API signatures that still had `IReadOnlyDictionary<k,v>` when they only ever needed `IReadOnlyCollection<KeyValuePair<TKey, TValue>>`
* Major docs and solution layout refactoring
- Prepares for providing docs for the support libraries used in samples
- The support libraries are valuable re-usable code of their own for anyone using the core LLVM library for DSLs
* Major refactoring of the docs input
* Now uses an msbuildproject configured with "notarget" to allow easy auto inclusion of folders and editing of contents
* Included supported utility libs as part of docs
- OVerviews/additional topics are mostly placeholders for now but infrastructure is there.
* Corrected some doc references
* Fixed build break from new use of SLNX format
* Updated docs
* Includes update to KLS highlighter
- Still doesn't work as DOCFX doesn't seem to even use the extension point. THe only sample provided for it (in SEED) uses a language that has BUILT-IN support so there's no validation that it's actually using the "custom" highlighter provided...
* Clarified that the Extreme lazy JIT does NOT allow re-definition at this point.
- Future variants might support removal in the following cases:
1) Not yet materialized.
2) Already materialized.
* Numerous refactorings
* Attempted, and failed to resolve the redfinition of a function problem with lazy JIT
* Moved KVP array helpers to an extension instead of statics on MaterializationUnit so other parts of ORC library can use them
* Added Definition Generator class
- Not currently used yet, but basic structure is there.
* Added ability to remove a JITDyLib from a session (by name)
* Addad ability to add a DefinitionGenerator to a JITDyLib
* Added ability to replace a amaterialization unit in a responsibility
* Refactored to suport native packaging model with one x-plat target only
* This does not construct the meta packages that handle per runtime metapackage with individual DLLs as packages. The combined Package for the `win-x64` rid is too large for NUGET to serve and requires splitting into the individual DLLs. Then a mega package could refer to them individually AND the source only package for the handles (which would be private assets).
* Updated build to consistency with the LibLLVM project (That was updated from this and then further enhanced for modern practices)
* Added Interop support for new registration model with most of the registration code shifted into the native code.
* Removed use of `Microsoft.Build.CentralPackageVersions` SDK in favor of built-in support.
* Docs Update
* Updated documentation comments
* Some minor typo fixes
* Minor update to Instruction builder
Fixes #224
* Corrected namespace usings for Test module fixtures
* Corrections for IDisposable handling
* Added runtime message formatting
* Adjusted to new target registration model
* Most of "registraion" is now done in the native code
* Library resolver will select the correct name based on the RID and LLVM target.
* Re-set build support to use new common build module format
* Also updated repo-build scripts to new native binary build format
* Added support for DistinctProcessTestMethod
- Allows testing of re-inits etc... of interop Library API as of right now only one init is allowed.
* Reformating CodeGenerator
* Refactoring Kaleidoscope parser
* Minor doc updates
* Re-worked samples to operate with new uncached and opaque pointers
* App MUST track pointer types
- Debug types in library can help but must be used and passed around as there is no caching to resolve to a managed type that includes the information.
* Corrected multiple cases of using reference equality checks for various constructs (mostly a Context).
- Really need an anyalizer to at least warn if performing any reference equality checks when IEquatable<T> is present. (Code is probably wrong)
* Global removed unused "using"
* Updated/corrected doc comments
* Added analyzer to find errors with use of reference equality when value equality should be used.
* Since this library removed the interning logic of LLVM types reference equality is NOT the same as value equality. So, all types impacted implement IEquatable<T> to allow testing to see if they are the same instance.
* Updated build scripts
* Moved Sample ASTNode to a re-usable library as it isn't specific to the Kaleidoscope language
* Recovery from collosal screw up with git branch rebasing...
* Added message or UWtable attribute usage check
* Massive re-work of attribute handling
* Removed all vestiges of the now really ancient bitmapped attributes
- This was from a pre-LLVM 3.9 era! and compat/transitionling from such an ancient way of doing things is not needed anymore.
- Requres updates to the native extensions to LLVM-C API
* The LLVM wrappers now distinguishes between an Enum attribute (No args) and an Enum with an int parameter.
- The underlying LLVM C++ api differnetiated these but the LLVM-C API combines them.
- LibLLVM and the wrapper now enables distinct testing for either condition.
* Converted attribute related P/Invoke signatures to use byte* instead of string to support use
of LazyEncoded string
* Move CallingConvention Enum to it's own file
* Fixed crashes from analyzer
- See: https://developercommunity.visualstudio.com/t/Keep-getting-errors-while-editing/10895357
* Fixed bugs in LazyEncoded string for empty strings (native)
* Added NativeStrLen to LazyEncodedString so that an accurate string length (not inluding any terminator) is avaliable.
* Fixed bugs in casting size_t values
* Generalized attribute handling for functions and callsites so that any issues for ALL locations are found in one of two places
- LLVM uses different API names for callsites vs functions/declarations.
* Fixed issue with Debug record reporting
* Fixed support for AOT
* Native library resolver now uses `TryLoad` to handle possibly different locations for the library depending on JIT/AOT runs.
NOTE: AOT publishing in VS is broken, dotnet publish command results in a working EXE though. (Although there are a couple of messages that look like errors but are not reported as such, and it does build a functioning app...)
* Updated to current version of ANTLR instead of fork
* This brings in latest patches but als removes downstream vulerable dependencies
- A few small source code changes were needed.
* Updated testing of interop helpers
* Refactored visualizers for the Kaleidoscope samples
* ALL samples are no set to publish as AOT.
- Note Publish from within VS using a profile is NOT supported. (It's basically broken AFAICT). `Dotnet publish` kinda sorta mostly works ;) [See:dotnet/runtime#115153].
- it works with the powershell scripting but it is possible to mis configure things and break the tooling... So be careful with local manual builds.
* Created a distinct interface for visualizers to allow a "callback" model from within a parser.
* Removes file write/behavior from the parser and allows implementers to do whatever (or nothing)
* Chapter 2 implements a visualizer that saves the content as a file.
* Added AOT friendly custom serializer for a DGML graph.
- The implementation coming from the 3rd party library uses XML serializers which requires dynamic reflection. Which breaks AOT scenarios. The library is NOT annotated for AOT support, but is otherwise OK.
* Updated analyzer to constrin checks to Ubiquity.NET.Llvm namespace
- Analyzer is NOT general purpose and only tested to check against this library
- Technically only tested with this library itself. Though it should become a viable component to include as an analyzer with the library so that consumers can catch issues.
* Reduced scope of unsafe for function calls in Kaleidscope JIT samples
* Refactored analyzer for simpler maintainability
* Build action updates
* Doc updates
* Elimination of old doc articles not in this repo anymore.
* Update spelling errors caught by better tool for spell checking more file types.
* renamed extension method for greater clarity of intent.
* Spell checker updates
* Error reporter updates
* Renamed interface to "reporter" to avoid confusion with "logger" as that term has more specific meaning in administrative log file generation which is different from end-user UX.
---------
Co-authored-by: Steven Maillet <[email protected]>
* Removed legacy bindings generator not longer part of this repo
* Deleting generated doc files that should not be part of SCCM
* Removed clone of docs build script
* Updated support for highlight JS so it actually works now!
* Update branch name in action YAML
* removed bindings generator from TOC
* Updated analyzer to skip value types
* Also removed quick experiment that was accidentally committed [OOPS!]
* Docs Build update
* Includes some typo corrections in the markdown files
* Reworks the docfx.json project for greater readability
- That's a complicated beast with little in the way of good docs.
- What docs do exist are not consistent with either the officially published schema or, the actual use...
* Corrected typos in the `documentation.msbuildproj` file
* Removed reference to legacy ruleset from solution.
- no longer used (or even in tree)
* Bumped version XML to match current LLVM values
- While there isn't a guarantee of matching numbers, best effort is applied so that as long as it is possible/reasonable it is done.
- In other words, break this pattern only if necessary.
* Updated common build support so it can actually run on automated builds
- Resynched so that common build is not the same as the LibLLVM repo
* Refined derivation checks to handle interfaces as the "base" uniquely
* updated message on docs build project for clarity and easier readability in build logs.
* Updated Build-docs to support automated build of docs
- Addition of analyzer triggers a warning, which is treated as an error by the build.
* Updated docs build for automation.
- Added more logging to figure out why it is complaining that the analyzer isn't built...
- Updated spelling dictionary
* Shifts to directly calling the build-docs script and FullInit from there.
- DOCFX has a problem where it detects analyzers even if the MSBUILD setting to disable them is provided.
- The former build had treated docfx warnings as errors and that failed the action.
- That's the big one that's causing the most pain so is removed in this commit.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This is a massive update to support LLVM20. It was done in a fork to allow for unreleased native lib builds. (One of the problems of keeping them distinct, which is driving a rethink on that point). Now that the native library support has reached a stable point (and an "alpha" release of the libs) this is moving to smaller updates against this larger "feature" branch. Now that it is ready for a complete build with docs it will merge to the
developbranch. All future work on this library is done against the "develop" branch and all of it is based on the LLVM 20 support.Onwards towards a full release!