dsc v0.9.6

This version of Flame/dsc includes the following improvements:

• The in-memory IR for gotos has been overhauled and should now play nice with the CFG optimization passes. This change also means that yield return/yield break should work just fine for all optimization settings now.

• Direct IR support for switch statements has been added. For integer types, SwitchStatement uses a combination of linear equality comparisons, bit tests, jump tables and balanced binary search trees to generate efficient code for targets that support branches.

• CFG lowering now tries to create switch statements for integral types. What that means is that code like this

  if (x == 1 || x == 2 || x == 3 || x == 54)
      return x;
  else if (x == 80)
      return 9;
  else
      return x * x;

  is compiled (from -O2 upward) as

  switch (x) {
  case 1:
  case 2:
  case 3:
  case 54:
      return x;
  case 80:
      return 9;
  default:
      return x * x;
  }

• Signature passes are more powerful now. They can access global metadata for the current assembly and make arbitrary changes to attribute maps now.

• The -frelax-access signature pass was born. It changes the access modifiers of private members to internal and makes protected members protected internal. That exposes optimization opportunities for other passes, which previously constrained by access modifiers.

• Flame's Json.NET package dependency has been updated to version 10.0.1.

dsc v0.9.4

This release of Flame/dsc mostly contains bugfixes and a couple of minor improvements. Specifically,

• boxing an enum literal will now indeed result in a boxed enum, rather than a boxed primitive type,
• boxing a char literal will now result in a boxed char instead of a boxed int16 (this was a CLR backend only bug),
• attributes of types that refer to themselves in their base types will no longer be discarded,
• CLR delegates are first-class delegates now; calling .GetIsDelegate() on CLR delegates returns true instead of false, and
• PointerKind has been made thread-safe.

dsc v0.9.3

This version of Flame/dsc adds support for user-defined conversions and fixes some dsc-specific operator overloading bugs with addition, left shifts, and right shifts.

dsc v0.9.0

In addition to the usual various improvements made in every Flame release, Flame v0.9.0 comes bundled with an alias-analysis based -foptimize-new-struct pass. It will apply in-place construction quite aggressively, and is enabled by default starting at -O2. To the best of my knowledge, this optimization is both more correct (see this Roslyn issue) and usually more aggressive than the equivalent optimizations in csc and mcs.

dsc v0.8.5

This version of dsc offers a few bug fixes, and adds a new optimization pass: -felide-runtime-casts, which tries to elide redundant runtime casts. The new optimization is activated at the -O2 optimization level, as well as any higher optimization levels.

Furthermore, the SSA optimization passes will now try to promote arguments to SSA variables, and then recycle the argument variables during the SSA deconstruction process. This should improve codegen in some cases, as it enables the compiler to apply the normal SSA-based scalar optimizations to argument variables.

dsc v0.8.3

This version of dsc offers improved assembly resolution support on Windows, which is needed for CI testing.

dsc v0.8.2

This version of dsc is mostly an incremental improvement over previous versions. It comes with support for field initialization and CLR library referencing.

dsc v0.7.5

This version of dsc fixes a few bugs and includes a number of tiny optimizations. The main highlight of this release is that a Flame.Front NuGet package is available from this release onward.

dsc v0.7.4

This new version of dsc ships with the following features:

• Support for exception handling when compiling with -O3
• Additional optimization passes, such as -fscalarrepl (scalar replacement of aggregates) and -foptimize-new-struct (optimizes new operator for value types).
• An experimental WebAssembly back-end, which outputs S-expressions. Only a small number of features are supported by this back-end at the time of writing. Additionally, note that the WebAssembly specification has not been finalized yet, so the output *.wast files may not be compatible with all (future) programs that take WebAssembly as input.
• A breaking change in how objects are constructed by the IR. Previously, a call to a constructor with a null object would construct a new object. This has now been replaced by the NewObjectExpression class and the #new_object on-disk IR node. This improves the accuracy of various passes and simplifies the implementation of back-end and middle-end code. However, this change also implies that old *.fir and *.flo files will be considered invalid by the new compiler, so they'll have to be regenerated.

dsc v0.7.3

This version of dsc fixes some bugs, and also features proper CFG/SSA-based -O3 optimization. Specifying -O3 will perform the following transformations:

• constant propagation
• copy propagation
• jump threading
• local variable type inference
• devirtualization
• dead store elimination
• dead block elimination
• inlining

Note: -O3 does not support exception handling at this time.