Do not lift functions that are not in the JSON spec (#102)

* Modifies lifting to ignore functions that do not have mapped bytes in the spec

* Moves byte existence and executability check to LifFunction() and adds comments

lib/Lift.cpp

@@ -617,23 +617,44 @@ bool LiftCodeIntoModule(const remill::Arch *arch, const Program &program,
 
   // Lift global variables.
   program.ForEachVariable([&](const anvill::GlobalVarDecl *decl) {
-    const auto addr = decl->address;
-    const auto name = anvill::CreateVariableName(addr);
-    const auto gvar = decl->DeclareInModule(name, module);
+    const auto addr{decl->address};
+    const auto name{anvill::CreateVariableName(addr)};
+    const auto gvar{decl->DeclareInModule(name, module)};
 
+    // Check if we have mapped bytes
+    if (!program.FindByte(addr)) {
+      return true;
+    }
     // Set initializer
-    auto init = CreateConstFromMemory(addr, decl->type, arch, program, module);
+    auto init{CreateConstFromMemory(addr, decl->type, arch, program, module)};
     gvar->setInitializer(init);
-
     return true;
   });
 
   // Lift functions.
   program.ForEachFunction([&](const FunctionDecl *decl) {
-    const auto entry = lifter.LiftFunction(*decl);
-    DefineNativeToLiftedWrapper(arch, *decl, entry);
+    // Initialize function entry. This will lift machine code
+    // into `entry.lifted` if instruction bytes for are
+    // available and declare `entry.lifted_to_native` and
+    // `entry.lifted_to_native` wrapper functions that
+    // are needed for further lifting to native functions.
+    const auto entry{lifter.LiftFunction(*decl)};
+
+    // We have `entry.lifted` available. `entry.lifted`
+    // will be inlined into `entry.native_to_lifted`.
+    if (!entry.lifted->isDeclaration()) {
+      DefineNativeToLiftedWrapper(arch, *decl, entry);
+    }
+    // Wrap native functions in a function that lifted
+    // functions can call. This will result in the
+    // lifted functions calling the native ones.
     DefineLiftedToNativeWrapper(*decl, entry);
+
+    // Optimize and inline. After this we should end up
+    // with only native functions.
     OptimizeFunction(entry.native_to_lifted);
+
+    // The ritual is done.
     return true;
   });
 

lib/MCToIRLifter.cpp

@@ -455,6 +455,11 @@ FunctionEntry MCToIRLifter::LiftFunction(const FunctionDecl &decl) {
   if (!entry.native_to_lifted->isDeclaration()) {
     return entry;
   }
+  // Check if there's any instruction bytes to lift
+  if (auto start{program.FindByte(decl.address)};
+      !start || !start.IsExecutable()) {
+    return entry;
+  }
 
   work_list.clear();
   addr_to_block.clear();