Continue parsing after unsupported BootstrapMethods entry

Before it was possible to keep some `BootstrapMethods` entries unparsed, after a
currently unsupported was found. This lead to the situation that JBMC ended up
with a wrong file offset which caused problems in the case of class file
attributes being present after the `BootstrapMethods` attribute.

This was not observed using the Oracle or OpenJDK compilers, but currently only
on the Eclipse compiler for Java.

Author: Matthias Güdemann

src/java_bytecode/java_bytecode_parser.cpp

@@ -1803,7 +1803,7 @@ java_bytecode_parsert::parse_method_handle(const method_handle_infot &entry)
 void java_bytecode_parsert::read_bootstrapmethods_entry(classt &parsed_class)
 {
   u2 num_bootstrap_methods = read_u2();
-  for(size_t i = 0; i < num_bootstrap_methods; i++)
+  for(size_t j = 0; j < num_bootstrap_methods; j++)
   {
     u2 bootstrap_methodhandle_ref = read_u2();
     const pool_entryt &entry = pool_entry(bootstrap_methodhandle_ref);
@@ -1868,72 +1868,81 @@ void java_bytecode_parsert::read_bootstrapmethods_entry(classt &parsed_class)
         lambda_method_handlet lambda_method_handle;
         lambda_method_handle.handle_type = method_handle_typet::UNKNOWN_HANDLE;
         lambda_method_handle.u2_values = std::move(u2_values);
-        parsed_class.lambda_method_handle_map[{parsed_class.name, i}] =
+        parsed_class.lambda_method_handle_map[{parsed_class.name, j}] =
           lambda_method_handle;
-        return;
-      }
-      const pool_entryt &interface_type_argument = pool_entry(argument_index1);
-      const pool_entryt &method_handle_argument = pool_entry(argument_index2);
-      const pool_entryt &method_type_argument = pool_entry(argument_index3);
-
-      if(
-        !(interface_type_argument.tag == CONSTANT_MethodType &&
-          method_handle_argument.tag == CONSTANT_MethodHandle &&
-          method_type_argument.tag == CONSTANT_MethodType))
-      {
-        lambda_method_handlet lambda_method_handle;
-        lambda_method_handle.handle_type = method_handle_typet::UNKNOWN_HANDLE;
-        lambda_method_handle.u2_values = std::move(u2_values);
-        parsed_class.lambda_method_handle_map[{parsed_class.name, i}] =
-          lambda_method_handle;
-        return;
-      }
-
-      debug() << "INFO: parse lambda handle" << eom;
-      optionalt<lambda_method_handlet> lambda_method_handle =
-        parse_method_handle(method_handle_infot{method_handle_argument});
-
-      if(!lambda_method_handle.has_value())
-      {
-        lambda_method_handlet lambda_method_handle;
-        lambda_method_handle.handle_type = method_handle_typet::UNKNOWN_HANDLE;
-        lambda_method_handle.u2_values = std::move(u2_values);
-        parsed_class.lambda_method_handle_map[{parsed_class.name, i}] =
-          lambda_method_handle;
-        return;
-      }
-      else if(
-        lambda_method_handle->handle_type !=
-        method_handle_typet::LAMBDA_METHOD_HANDLE)
-      {
-        lambda_method_handle->u2_values = std::move(u2_values);
-        error() << "ERROR: could not parse lambda function method handle"
-                << eom;
       }
       else
       {
-        lambda_method_handle->interface_type =
-          pool_entry(interface_type_argument.ref1).s;
-        lambda_method_handle->method_type =
-          pool_entry(method_type_argument.ref1).s;
-        lambda_method_handle->u2_values = std::move(u2_values);
-        debug() << "lambda function reference "
-                << id2string(lambda_method_handle->lambda_method_name)
-                << " in class \"" << parsed_class.name << "\""
-                << "\n  interface type is "
-                << id2string(pool_entry(interface_type_argument.ref1).s)
-                << "\n  method type is "
-                << id2string(pool_entry(method_type_argument.ref1).s) << eom;
+        const pool_entryt &interface_type_argument =
+          pool_entry(argument_index1);
+        const pool_entryt &method_handle_argument = pool_entry(argument_index2);
+        const pool_entryt &method_type_argument = pool_entry(argument_index3);
+
+        if(
+          !(interface_type_argument.tag == CONSTANT_MethodType &&
+            method_handle_argument.tag == CONSTANT_MethodHandle &&
+            method_type_argument.tag == CONSTANT_MethodType))
+        {
+          lambda_method_handlet lambda_method_handle;
+          lambda_method_handle.handle_type =
+            method_handle_typet::UNKNOWN_HANDLE;
+          lambda_method_handle.u2_values = std::move(u2_values);
+          parsed_class.lambda_method_handle_map[{parsed_class.name, j}] =
+            lambda_method_handle;
+        }
+        else
+        {
+          debug() << "INFO: parse lambda handle" << eom;
+          optionalt<lambda_method_handlet> lambda_method_handle =
+            parse_method_handle(method_handle_infot{method_handle_argument});
+
+          if(!lambda_method_handle.has_value())
+          {
+            lambda_method_handlet lambda_method_handle;
+            lambda_method_handle.handle_type =
+              method_handle_typet::UNKNOWN_HANDLE;
+            lambda_method_handle.u2_values = std::move(u2_values);
+            parsed_class.lambda_method_handle_map[{parsed_class.name, j}] =
+              lambda_method_handle;
+          }
+          else
+          {
+            if(
+              lambda_method_handle->handle_type !=
+              method_handle_typet::LAMBDA_METHOD_HANDLE)
+            {
+              lambda_method_handle->u2_values = std::move(u2_values);
+              error() << "ERROR: could not parse lambda function method handle"
+                      << eom;
+            }
+            else
+            {
+              lambda_method_handle->interface_type =
+                pool_entry(interface_type_argument.ref1).s;
+              lambda_method_handle->method_type =
+                pool_entry(method_type_argument.ref1).s;
+              lambda_method_handle->u2_values = std::move(u2_values);
+              debug() << "lambda function reference "
+                      << id2string(lambda_method_handle->lambda_method_name)
+                      << " in class \"" << parsed_class.name << "\""
+                      << "\n  interface type is "
+                      << id2string(pool_entry(interface_type_argument.ref1).s)
+                      << "\n  method type is "
+                      << id2string(pool_entry(method_type_argument.ref1).s)
+                      << eom;
+            }
+            parsed_class.lambda_method_handle_map[{parsed_class.name, j}] =
+              *lambda_method_handle;
+          }
+        }
       }
-      parsed_class.lambda_method_handle_map[{parsed_class.name, i}] =
-        *lambda_method_handle;
     }
     else
     {
       lambda_method_handlet lambda_method_handle;
       lambda_method_handle.handle_type = method_handle_typet::UNKNOWN_HANDLE;
       lambda_method_handle.u2_values = std::move(u2_values);
-      parsed_class.lambda_method_handle_map[{parsed_class.name, i}] =
+      parsed_class.lambda_method_handle_map[{parsed_class.name, j}] =
         lambda_method_handle;
       error() << "ERROR: num_bootstrap_arguments must be at least 3" << eom;
     }