Exception edges for live range analysis master

src/java_bytecode/java_bytecode_convert_method_class.h

@@ -129,7 +129,8 @@ class java_bytecode_convert_methodt:public messaget
 
 public:
   typedef std::map<unsigned, converted_instructiont> address_mapt;
-  typedef cfg_dominators_templatet<const address_mapt, unsigned, false>
+  typedef std::pair<const methodt&, const address_mapt&> method_with_amapt;
+  typedef cfg_dominators_templatet<method_with_amapt, unsigned, false>
     java_cfg_dominatorst;
 
 protected:

src/java_bytecode/java_bytecode_parse_tree.h

@@ -82,8 +82,12 @@ class java_bytecode_parse_treet
       return instructions.back();
     }
 
-    class exceptiont
+    struct exceptiont
     {
+      std::size_t start_pc;
+      std::size_t end_pc;
+      std::size_t handler_pc;
+      symbol_typet catch_type;
     };
 
     typedef std::vector<exceptiont> exception_tablet;

src/java_bytecode/java_bytecode_parser.cpp

@@ -968,13 +968,20 @@ void java_bytecode_parsert::rmethod_attribute(methodt &method)
     rbytecode(method.instructions);
 
     u2 exception_table_length=read_u2();
+    method.exception_table.resize(exception_table_length);
 
     for(std::size_t e=0; e<exception_table_length; e++)
     {
-      u2 UNUSED start_pc=read_u2();
-      u2 UNUSED end_pc=read_u2();
-      u2 UNUSED handler_pc=read_u2();
-      u2 UNUSED catch_type=read_u2();
+      u2 start_pc=read_u2();
+      u2 end_pc=read_u2();
+      u2 handler_pc=read_u2();
+      u2 catch_type=read_u2();
+      method.exception_table[e].start_pc=start_pc;
+      method.exception_table[e].end_pc=end_pc;
+      method.exception_table[e].handler_pc=handler_pc;
+      if(catch_type!=0)
+        method.exception_table[e].catch_type=
+          to_symbol_type(pool_entry(catch_type).expr.type());
     }
 
     u2 attributes_count=read_u2();

src/java_bytecode/java_local_variable_table.cpp

@@ -20,18 +20,20 @@ Author: Chris Smowton, [email protected]
 template<class T>
 struct procedure_local_cfg_baset<
   T,
-  const java_bytecode_convert_methodt::address_mapt,
+  java_bytecode_convert_methodt::method_with_amapt,
   unsigned> :
   public graph<cfg_base_nodet<T, unsigned> >
 {
-  typedef java_bytecode_convert_methodt::address_mapt address_mapt;
+  typedef java_bytecode_convert_methodt::method_with_amapt method_with_amapt;
   typedef std::map<unsigned, unsigned> entry_mapt;
   entry_mapt entry_map;
 
   procedure_local_cfg_baset() {}
 
-  void operator()(const address_mapt& amap)
+  void operator()(const method_with_amapt& args)
   {
+    const auto &method=args.first;
+    const auto& amap=args.second;
     for(const auto& inst : amap)
     {
       // Map instruction PCs onto node indices:
@@ -44,19 +46,44 @@ struct procedure_local_cfg_baset<
       for(auto succ : inst.second.successors)
         this->add_edge(entry_map.at(inst.first), entry_map.at(succ));
     }
+    // Add edges declared in the exception table, which don't figure
+    // in the address map successors/predecessors as yet.
+    for(const auto& table_entry : method.exception_table)
+    {
+      auto findit=amap.find(table_entry.start_pc);
+      assert(findit!=amap.end() &&
+             "Exception table entry doesn't point to an instruction?");
+      for(; findit->first<table_entry.end_pc; ++findit)
+      {
+        // For now just assume any non-branch
+        // instruction could potentially throw.
+        auto succit=findit;
+        ++succit;
+        if(succit==amap.end())
+          continue;
+        const auto& thisinst=findit->second;
+        if(thisinst.successors.size()==1 &&
+           *thisinst.successors.begin()==succit->first)
+        {
+          this->add_edge(
+            entry_map.at(findit->first),
+            entry_map.at(table_entry.handler_pc));
+        }
+      }
+    }
   }
 
-  unsigned get_first_node(const address_mapt& amap) const
+  unsigned get_first_node(const method_with_amapt& args) const
   {
-    return amap.begin()->first;
+    return args.second.begin()->first;
   }
-  unsigned get_last_node(const address_mapt& amap) const
+  unsigned get_last_node(const method_with_amapt& args) const
   {
-    return (--amap.end())->first;
+    return (--args.second.end())->first;
   }
-  unsigned nodes_empty(const address_mapt& amap) const
+  unsigned nodes_empty(const method_with_amapt& args) const
   {
-    return amap.empty();
+    return args.second.empty();
   }
 };
 
@@ -744,7 +771,8 @@ void java_bytecode_convert_methodt::setup_local_variables(
 {
   // Compute CFG dominator tree
   java_cfg_dominatorst dominator_analysis;
-  dominator_analysis(amap);
+  method_with_amapt dominator_args(m,amap);
+  dominator_analysis(dominator_args);
 
   // Find out which local variable table entries should be merged:
   // Wrap each entry so we have somewhere to record live ranges with holes: