Ejemplo n.º 1
0
        private static Task <CudaModule> CompileAsync(
            MethodReference method,
            IEnumerable <MethodReference> methodRoots,
            IEnumerable <TypeReference> typeRoots,
            int threadIdParamIndex,
            CudaContext context)
        {
            var module      = method.Module;
            var flameModule = ClrAssembly.Wrap(module.Assembly);

            return(CompileAsync(
                       flameModule.Resolve(method),
                       methodRoots.Select(flameModule.Resolve).ToArray(),
                       typeRoots.Select(flameModule.Resolve).ToArray(),
                       threadIdParamIndex,
                       flameModule,
                       context));
        }
Ejemplo n.º 2
0
        public static int Main(string[] args)
        {
            // Acquire a log.
            var rawLog = TerminalLog.Acquire();

            log = new TransformLog(
                rawLog,
                new Func <LogEntry, LogEntry>[]
            {
                MakeDiagnostic
            });

            // Parse command-line options.
            var parser = new GnuOptionSetParser(
                Options.All, Options.Input);

            var recLog        = new RecordingLog(log);
            var parsedOptions = parser.Parse(args, recLog);

            if (recLog.Contains(Severity.Error))
            {
                // Stop the program if the command-line arguments
                // are half baked.
                return(1);
            }

            if (parsedOptions.GetValue <bool>(Options.Help))
            {
                // Wrap the help message into a log entry and send it to the log.
                TerminalLog.AcquireStandardOutput().Log(
                    new LogEntry(
                        Severity.Info,
                        new HelpMessage(
                            "il2llvm is a command-line tool that compiles CIL assemblies to LLVM modules.",
                            "il2llvm path [options...]",
                            Options.All)));
                return(0);
            }

            var inputPath = parsedOptions.GetValue <string>(Options.Input);

            if (string.IsNullOrEmpty(inputPath))
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "nothing to compile",
                        "no input file"));
                return(1);
            }

            var outputPath = parsedOptions.GetValue <string>(Options.Output);

            if (string.IsNullOrEmpty(outputPath))
            {
                outputPath = Path.GetFileNameWithoutExtension(inputPath) + ".ll";
            }

            var printIr = parsedOptions.GetValue <bool>(Options.PrintIr);

            // Read the assembly from disk.
            Mono.Cecil.AssemblyDefinition cecilAsm;
            try
            {
                cecilAsm = Mono.Cecil.AssemblyDefinition.ReadAssembly(
                    inputPath,
                    new Mono.Cecil.ReaderParameters
                {
                    ReadWrite = false
                });
            }
            catch (Exception)
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "unreadable assembly",
                        Quotation.QuoteEvenInBold(
                            "cannot read assembly at ",
                            inputPath,
                            ".")));
                return(1);
            }

            if (cecilAsm.EntryPoint == null)
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "unsuitable assembly",
                        "input assembly does not define an entry point."));
                return(1);
            }

            try
            {
                // Wrap the CIL assembly in a Flame assembly.
                var flameAsm = ClrAssembly.Wrap(cecilAsm);

                // Compile the assembly to an LLVM module.
                var module = CompileAsync(flameAsm).Result;

                // Write the LLVM module to disk.
                string error;
                if (LLVM.PrintModuleToFile(module, outputPath, out error))
                {
                    log.Log(new LogEntry(Severity.Error, "cannot write module", error));
                }

                LLVM.DisposeModule(module);
            }
            finally
            {
                // Be sure to dispose the assembly after we've used it.
                cecilAsm.Dispose();
            }

            return(0);
        }
Ejemplo n.º 3
0
        public static int Main(string[] args)
        {
            // Acquire a log.
            var rawLog = TerminalLog.Acquire();

            log = new TransformLog(
                rawLog,
                new Func <LogEntry, LogEntry>[]
            {
                MakeDiagnostic
            });

            // Parse command-line options.
            var parser = new GnuOptionSetParser(
                Options.All, Options.Input);

            var recLog        = new RecordingLog(log);
            var parsedOptions = parser.Parse(args, recLog);

            if (recLog.Contains(Severity.Error))
            {
                // Stop the program if the command-line arguments
                // are half baked.
                return(1);
            }

            if (parsedOptions.GetValue <bool>(Options.Help))
            {
                // Wrap the help message into a log entry and send it to the log.
                TerminalLog.AcquireStandardOutput().Log(
                    new LogEntry(
                        Severity.Info,
                        new HelpMessage(
                            "ilopt is a command-line tool that optimizes CIL assemblies.",
                            "ilopt path [options...]",
                            Options.All)));
                return(0);
            }

            var inputPath = parsedOptions.GetValue <string>(Options.Input);

            if (string.IsNullOrEmpty(inputPath))
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "nothing to optimize",
                        "no input file"));
                return(1);
            }

            var outputPath = parsedOptions.GetValue <string>(Options.Output);

            if (string.IsNullOrEmpty(outputPath))
            {
                outputPath = Path.GetFileNameWithoutExtension(inputPath) + ".opt" + Path.GetExtension(inputPath);
            }

            var printIr = parsedOptions.GetValue <bool>(Options.PrintIr);

            // Read the assembly from disk.
            Mono.Cecil.AssemblyDefinition cecilAsm;
            try
            {
                cecilAsm = Mono.Cecil.AssemblyDefinition.ReadAssembly(
                    inputPath,
                    new Mono.Cecil.ReaderParameters
                {
                    ReadWrite = false
                });
            }
            catch (Exception)
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "unreadable assembly",
                        Quotation.QuoteEvenInBold(
                            "cannot read assembly at ",
                            inputPath,
                            ".")));
                return(1);
            }

            try
            {
                // Make all non-public types, methods and fields in the assembly
                // internal if the user requests it. This will work to
                // our advantage.
                if (parsedOptions.GetValue <bool>(Options.Internalize))
                {
                    MakeInternal(cecilAsm);
                }

                // Wrap the CIL assembly in a Flame assembly.
                var flameAsm = ClrAssembly.Wrap(cecilAsm);

                // Optimize the assembly.
                OptimizeAssemblyAsync(
                    flameAsm,
                    printIr,
                    parsedOptions.GetValue <bool>(Options.Parallel)).Wait();

                // Write the optimized assembly to disk.
                cecilAsm.Write(outputPath);
            }
            finally
            {
                // Be sure to dispose the assembly after we've used it.
                cecilAsm.Dispose();
            }

            return(0);
        }
Ejemplo n.º 4
0
        public static int Main(string[] args)
        {
            // Acquire a log.
            var rawLog = TerminalLog.Acquire();
            var log    = new TransformLog(
                rawLog,
                new Func <LogEntry, LogEntry>[]
            {
                MakeDiagnostic
            });

            // Parse command-line options.
            var parser = new GnuOptionSetParser(
                Options.All, Options.Input);

            var recLog        = new RecordingLog(log);
            var parsedOptions = parser.Parse(args, recLog);

            if (recLog.Contains(Severity.Error))
            {
                // Stop the program if the command-line arguments
                // are half baked.
                return(1);
            }

            if (parsedOptions.GetValue <bool>(Options.Help))
            {
                // Wrap the help message into a log entry and send it to the log.
                rawLog.Log(
                    new LogEntry(
                        Severity.Info,
                        new HelpMessage(
                            "fbfc is a compiler that turns Brainfuck code into CIL assemblies.",
                            "fbfc path [options...]",
                            Options.All)));
                return(0);
            }

            var inputPath = parsedOptions.GetValue <string>(Options.Input);

            if (string.IsNullOrEmpty(inputPath))
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "nothing to compile",
                        "no input file"));
                return(1);
            }

            var outputPath = parsedOptions.GetValue <string>(Options.Output);

            if (string.IsNullOrEmpty(outputPath))
            {
                outputPath = Path.GetFileNameWithoutExtension(inputPath) + ".exe";
            }

            // Read the Brainfuck source code from disk.
            SourceDocument source;

            try
            {
                source = new StringDocument(inputPath, File.ReadAllText(inputPath));
            }
            catch (Exception)
            {
                log.Log(
                    new LogEntry(
                        Severity.Error,
                        "invalid source path",
                        Quotation.QuoteEvenInBold(
                            "cannot read Brainfuck source code at ",
                            inputPath,
                            ".")));
                return(1);
            }

            var asmName  = Path.GetFileNameWithoutExtension(outputPath);
            var cecilAsm = Mono.Cecil.AssemblyDefinition.CreateAssembly(
                new Mono.Cecil.AssemblyNameDefinition(asmName, new Version(1, 0, 0, 0)),
                asmName,
                Mono.Cecil.ModuleKind.Console);

            var flameAsm = ClrAssembly.Wrap(cecilAsm);

            var typeEnv  = flameAsm.Resolver.TypeEnvironment;
            var compiler = new Compiler(
                flameAsm,
                Dependencies.Resolve(
                    typeEnv,
                    new ReadOnlyTypeResolver(typeEnv.Object.Parent.Assembly),
                    log),
                log,
                parsedOptions);

            compiler.Compile(source);

            cecilAsm.Write(outputPath);

            return(0);
        }