[Courgette] Reduce AssemblyProgram to reduce Courgette-apply RAM floor and disk churn.

courgette/courgette_flow.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/courgette_flow.h"
 
 #include <stdarg.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "courgette/assembly_program.h"
+#include "courgette/disassembler.h"
 #include "courgette/encoded_program.h"
 #include "courgette/program_detector.h"
 
 namespace courgette {
 
 /******** CourgetteFlow::Data ********/
 
 CourgetteFlow::Data::Data() = default;
 
 CourgetteFlow::Data::~Data() = default;
@@ skipping 55 matching lines @@
                                                   const BasicBuffer& buffer) {
   if (failed())
     return;
   Data* d = data(group);
   if (!check(d->sources.Init(buffer.data(), buffer.length()),
              C_GENERAL_ERROR)) {
     setMessage("Cannot read %s as SourceStreamSet.", name(group));
   }
 }
 
-void CourgetteFlow::ReadAssemblyProgramFromBuffer(Group group,
-                                                  const BasicBuffer& buffer,
-                                                  bool annotate) {
+void CourgetteFlow::ReadDisassemblerFromBuffer(Group group,
+                                               const BasicBuffer& buffer) {
   if (failed())
     return;
   Data* d = data(group);
-  auto parser = annotate ? ParseDetectedExecutableWithAnnotation
-                         : ParseDetectedExecutable;
-  if (!check(parser(buffer.data(), buffer.length(), &d->program)))
-    setMessage("Cannot parse %s (code = %d).", name(group), status_);
+  d->disassembler = DetectDisassembler(buffer.data(), buffer.length());
+  if (!check(d->disassembler.get() != nullptr, C_INPUT_NOT_RECOGNIZED))
+    setMessage("Cannot detect program for %s.", name(group));
 }
 
 void CourgetteFlow::ReadEncodedProgramFromSourceStreamSet(
     Group group,
     SourceStreamSet* opt_sources /* nullptr */) {
   if (failed())
     return;
   Data* d = data(group);
   SourceStreamSet* sources = opt_sources ? opt_sources : &d->sources;
   if (!check(ReadEncodedProgram(sources, &d->encoded)))
     setMessage("Cannot read %s as encoded program.", name(group));
 }
 
-void CourgetteFlow::CreateEncodedProgramFromAssemblyProgram(Group group) {
+void CourgetteFlow::CreateAssemblyProgramFromDisassembler(Group group,
+                                                          bool annotate) {
   if (failed())
     return;
   Data* d = data(group);
-  if (!check(Encode(*d->program, &d->encoded)))
-    setMessage("Cannot encode %s (code = %d).", name(group), status_);
+  d->program = d->disassembler->CreateProgram(annotate);
+  if (!check(d->program.get() != nullptr, C_DISASSEMBLY_FAILED))
+    setMessage("Cannot create AssemblyProgram for %s.", name(group));
+}
+
+void CourgetteFlow::CreateEncodedProgramFromDisassemblerAndAssemblyProgram(
+    Group group) {
+  if (failed())
+    return;
+  Data* d = data(group);
+  d->encoded.reset(new EncodedProgram());
+  if (!check(d->disassembler->DisassembleAndEncode(d->program.get(),
+                                                   d->encoded.get()))) {
+    setMessage("Cannot disassemble to form EncodedProgram for %s.",
+               name(group));
+  }
 }
 
 void CourgetteFlow::WriteSinkStreamFromSinkStreamSet(Group group,
                                                      SinkStream* sink) {
   DCHECK(sink);
   if (failed())
     return;
   if (!check(data(group)->sinks.CopyTo(sink), C_GENERAL_ERROR))
     setMessage("Cannnot combine serialized streams for %s.", name(group));
 }
@@ skipping 18 matching lines @@
     setMessage("Cannot assemble %s.", name(group));
 }
 
 void CourgetteFlow::AdjustNewAssemblyProgramToMatchOld() {
   if (failed())
     return;
   if (!check(Adjust(*data_old_.program, data_new_.program.get())))
     setMessage("Cannot adjust %s to match %s.", name(OLD), name(NEW));
 }
 
+void CourgetteFlow::DestroyDisassembler(Group group) {
+  if (failed())
+    return;
+  data(group)->disassembler.reset();
+}
+
 void CourgetteFlow::DestroyAssemblyProgram(Group group) {
   if (failed())
     return;
   data(group)->program.reset();
 }
 
 void CourgetteFlow::DestroyEncodedProgram(Group group) {
   if (failed())
     return;
   data(group)->encoded.reset();
@@ skipping 14 matching lines @@
 }
 
 void CourgetteFlow::setMessage(const char* format, ...) {
   va_list args;
   va_start(args, format);
   message_ = base::StringPrintV(format, args);
   va_end(args);
 }
 
 }  // namespace courgette