Fix: #1362

This commit fixes a crash in the COFF loader reported by @lighth7015.

You can now override the platform of any loader's Programs by specifying
the `--env` command line parameter to the Reko cli:

```
reko decompile --env msdos-386 DPMIAPP.EXE
```
will now work.

Author: uxmal

src/Arch/Cray/UnicosLoader.cs

@@ -90,7 +90,7 @@ public enum MachineType
             A_PMT_C90 = 8,          // CRAY C90 
         }
 
-        public override Program LoadProgram(Address? addrLoad)
+        public override Program LoadProgram(Address? addrLoad, string? platformOverride)
         {
             var rdr = new BeImageReader(RawImage);
             if (!rdr.TryReadBeUInt64(out ulong magic))
@@ -121,7 +121,7 @@ public override Program LoadProgram(Address? addrLoad)
                 new ImageSegment("text", text, AccessMode.ReadExecute),
                 new ImageSegment("data", data, AccessMode.ReadWrite),
                 new ImageSegment("bss", bss, AccessMode.ReadWrite));
-            var platform = cfgSvc.GetEnvironment("unicos").Load(Services, arch);
+            var platform = Platform.Load(Services, "unicos", platformOverride, arch);
             var program = new Program(new ByteProgramMemory(segs), arch, platform);
             var entry = ImageSymbol.Procedure(program.Architecture, Address.Ptr32((uint) a_entry), "_start");
             program.EntryPoints[entry.Address] = entry;

src/Core/Configuration/RekoConfigurationService.cs

@@ -67,9 +67,10 @@ public interface IConfigurationService
         /// <summary>
         /// Given an platform or environment name, gets its corresponding platform definition.
         /// </summary>
-        /// <param name="envName">Name of the environment.</param>
+        /// <param name="envName">Name of the environment. If null is passed, 
+        /// fall back to the <see cref="DefaultPlatform"/>.</param>
         /// <returns>A platform definition for that environment.</returns>
-        PlatformDefinition GetEnvironment(string envName);
+        PlatformDefinition GetEnvironment(string? envName);
 
         /// <summary>
         /// Given the name of an architecture, creates an instance of that architecture.
@@ -640,7 +641,7 @@ public virtual ICollection<RawFileDefinition> GetRawFiles()
         }
 
         /// <inheritdoc/>
-        public PlatformDefinition GetEnvironment(string envName)
+        public PlatformDefinition GetEnvironment(string? envName)
         {
             var env = GetEnvironments()
                 .Where(e => e.Name == envName).SingleOrDefault();

src/Core/Loading/ILoader.cs

@@ -43,6 +43,7 @@ public interface ILoader
         /// </summary>
         /// <param name="imageLocation">The <see cref="ImageLocation"/> from which</param>
         /// <param name="loader">Optional name of a specific image loader to use.</param>
+        /// <param name="environmentName">Optional name of operating environment to use.</param>
         /// <param name="addrLoad">Optional address at which to load the image.</param>
         /// <returns>
         /// An <see cref="ILoadedImage"/> instance. In particular, if the
@@ -52,6 +53,7 @@ public interface ILoader
         ILoadedImage Load(
             ImageLocation imageLocation,
             string? loader = null,
+            string? environmentName = null,
             Address? addrLoad = null);
 
         /// <summary>

src/Core/Loading/ProgramImageLoader.cs

@@ -54,16 +54,18 @@ public ProgramImageLoader(IServiceProvider services, ImageLocation imageLocation
         /// <returns>A <see cref="ILoadedImage"/>.</returns>
         public override ILoadedImage Load(Address? addrLoad)
         {
-            return LoadProgram(addrLoad);
+            return LoadProgram(addrLoad, null);
         }
 
         /// <summary>
         /// Loads a program image into memory.
         /// </summary>
         /// <param name="address">Optional base address of the program image. If not specified,
         /// use the image format's default loading address.</param>
+        /// <param name="platformOverride">Optional name of platform to use instead
+        /// of the one determined by the loader.</param>
         /// <returns>An object implementing the <see cref="ILoadedImage"/> interface.</returns>
-        public abstract Program LoadProgram(Address? address);
+        public abstract Program LoadProgram(Address? address, string? platformOverride);
 
         /// <summary>
         /// Loads the image into memory at the specified address, using the 

src/Core/Memory/ByteMemoryArea.cs

@@ -383,7 +383,10 @@ public static bool TryReadLe(byte[] abImage, long imageOffset, DataType type, ou
                 c = Constant.Create(type, l);
                 return true;
             default:
-               throw new NotImplementedException(string.Format("Primitive type {0} not supported.", type));
+                //$TODO:
+                // #1362: consider writing this to error output?
+                // throw new NotImplementedException(string.Format("Primitive type {0} not supported.", type));
+                break;
             }
             c = default!;
             return false;

src/Core/Platform.cs

@@ -1080,6 +1080,59 @@ public virtual (string, SerializedType, SerializedType)? DataTypeFromImportName(
         public virtual void WriteMetadata(Program program, string path)
         {
         }
+
+        /// <summary>
+        /// Helper method used to obtain an <see cref="IPlatform"/> implementation,
+        /// given an optional override.
+        /// </summary>
+        /// <param name="services"><see cref="IServiceProvider"/> instance to use.</param>
+        /// <param name="platform"><see cref="IPlatform"/> instance to use if no <paramref name="sPlatformOverride" />
+        /// <param name="sPlatformOverride">Name of platform to use. If null, the method falls 
+        /// back to using the provided <paramref name="platform"/>.</param>
+        /// is provided.</param>
+        /// <param name="arch">Processor architecture to use when obtaining the <see cref="IPlatform"/>
+        /// instance</param>
+        /// <returns>An <see cref="IPlatform"/> instance.</returns>
+        public static IPlatform Load(
+            IServiceProvider services,
+            IPlatform? platform, 
+            string? sPlatformOverride,
+            IProcessorArchitecture arch)
+        {
+            if (string.IsNullOrWhiteSpace(sPlatformOverride) && platform is not null)
+                return platform;
+            var cfgSvc = services.RequireService<IConfigurationService>();
+            var platform2 = cfgSvc.GetEnvironment(sPlatformOverride)
+                .Load(services, arch);
+            return platform2;
+        }
+
+        /// <summary>
+        /// Helper method used to obtain an <see cref="IPlatform"/> implementation,
+        /// given an optional override.
+        /// </summary>
+        /// <param name="services"><see cref="IServiceProvider"/> instance to use.</param>
+        /// <param name="sPlatform">Name of the platform to use if no <paramref name="sPlatformOverride" /> was provided.
+        /// </param>
+        /// <param name="sPlatformOverride">Name of platform to use. If null, the method falls 
+        /// back to using the provided <paramref name="sPlatform"/>.</param>
+        /// <param name="arch">Processor architecture to use when obtaining the <see cref="IPlatform"/>
+        /// instance</param>
+        /// <returns>An <see cref="IPlatform"/> instance.</returns>
+        public static IPlatform Load(
+            IServiceProvider services,
+            string? sPlatform,
+            string? sPlatformOverride,
+            IProcessorArchitecture arch)
+        {
+            if (!string.IsNullOrWhiteSpace(sPlatformOverride))
+                sPlatform = sPlatformOverride;
+            var cfgSvc = services.RequireService<IConfigurationService>();
+            var platform = cfgSvc.GetEnvironment(sPlatform)
+                .Load(services, arch);
+            return platform;
+        }
+
     }
 
     /// <summary>

src/Core/Serialization/ProjectLoader.cs

@@ -314,7 +314,7 @@ private Program LoadProgram(ImageLocation projectLocation, DecompilerInput_v5 sI
             }
             else
             {
-                if (loader.Load(binLocation, null, address) is not Program p)
+                if (loader.Load(binLocation, null, sUser.PlatformOptions?.Name, address) is not Program p)
                 {
                     // A previous save of the project was able to read the file, 
                     // but now we can't...

src/Decompiler/Loading/Loader.cs

@@ -125,14 +125,20 @@ public Program AssembleExecutable(ImageLocation asmFileLocation, byte[] image, I
         /// <param name="imageLocation">The location of the image to load.</param>
         /// <param name="loaderName">Optional .NET class name of a custom
         /// image loader</param>
+        /// <param name="environmentName">Optional name of the environment
+        /// to use, overriding any environment loaded by the image loader.</param>
         /// <param name="addrLoad">Optional address at which to load the image.
         /// </param>
         /// <returns>
         /// An <see cref="ILoadedImage"/> instance. In particular, if the
         /// file format wasn't recognized an instance of <see cref="Blob"/> is
         /// returned.
         /// </returns>
-        public ILoadedImage Load(ImageLocation imageLocation, string? loaderName = null, Address? addrLoad = null)
+        public ILoadedImage Load(
+            ImageLocation imageLocation,
+            string? loaderName = null,
+            string? environmentName = null,
+            Address? addrLoad = null)
         {
             byte[] image = LoadFileBytes(imageLocation.FilesystemPath);
 
@@ -334,11 +340,7 @@ public Program ParseRawImage(byte[] image, Address? loadingAddress, LoadDetails
             if (arch is null)
                 throw new ApplicationException($"Unknown processor architecture '{details.ArchitectureName}");
             arch.LoadUserOptions(details.ArchitectureOptions);
-            IPlatform platform;
-            if (details.PlatformName is null)
-                platform = new DefaultPlatform(Services, arch);
-            else 
-                platform = cfgSvc.GetEnvironment(details.PlatformName).Load(Services, arch);
+            IPlatform platform = Platform.Load(Services, details.PlatformName, null, arch);
             Address addrLoad;
             if (loadingAddress is null)
             {

src/Decompiler/Loading/NullImageLoader.cs

@@ -73,7 +73,7 @@ public override Address PreferredBaseAddress
         }
 
         /// <inheritdoc/>
-        public override Program LoadProgram(Address? addrLoad)
+        public override Program LoadProgram(Address? addrLoad, string? platformOverride)
         {
             if (Architecture is null)
                 throw new InvalidOperationException("A processor architecture must be specified.");
@@ -87,7 +87,7 @@ public override Program Load(Address? addrLoad, IProcessorArchitecture? arch)
                 throw new InvalidOperationException("A processor architecture must be specified.");
             if (addrLoad is null)
                 addrLoad = PreferredBaseAddress;
-            var platform = Platform ?? new DefaultPlatform(Services, arch);
+            var platform = Reko.Core.Platform.Load(Services, Platform, "", arch);
             return LoadProgram(addrLoad.Value, arch, platform, new());
         }
 

src/Drivers/CmdLine/CmdLineDriver.cs

@@ -169,13 +169,14 @@ public static bool OverridesRequested(Dictionary<string,object> pArgs)
         private void Decompile(Dictionary<string, object> pArgs)
         {
             pArgs.TryGetValue("--loader", out object? imgLoader);
+            pArgs.TryGetValue("--env", out object? environmentName);
             var addrLoad = ParseAddress(pArgs, "--base");
             try
             {
                 var fileName = (string) pArgs["filename"];
                 var filePath = Path.GetFullPath(fileName);
                 var imageLocation = ImageLocation.FromUri(filePath);
-                var loadedImage = ldr.Load(imageLocation, (string?) imgLoader, addrLoad);
+                var loadedImage = ldr.Load(imageLocation, (string?) imgLoader, (string?)environmentName,  addrLoad);
                 Project project;
                 switch (loadedImage)
                 {