bytedeco/javacpp

infinite recursion when calling virtualized inherited function

Open

#723 opened on Oct 21, 2023

View on GitHub
 (4 comments) (0 reactions) (0 assignees)Java (4,279 stars) (620 forks)batch import
enhancementhelp wanted

Description

struct B {
  int x;
  virtual void f() { }
  virtual ~B() { };
};

struct D: public B {
  int y;
};

infoMap
  .put(new Info("B").virtualize())
  .put(new Info("B::x").annotations("@NoOffset"));

class Test {
  public static void main(String[] a) {
    D d = new D();
    d.f();
  }
}

This triggers an infinite recursion:

  1. Java d.f is called. f is not overridden in Java, so Java B.f is called
  2. JNI Java_B_f is called. Since B is virtualized, instead of calling C++ B::f, the object is checked whether if's an instance of the peer class JavaCPP_B. It's not the case, the object is a JavaCPP_D, and JavaCPP_D doesn't derive from JavaCPP_B. So f is called on the object, that is JavaCPP_D::f.
  3. JavaCPP_D::f calls Java d.f.

How to solve this ? Shouldn't JavaCPP_D derives from JavaCPP_B in addition of deriving from D ? Or should we call explicity B::f and bypass dynamic invocation at the end of 2. ?

Contributor guide

Tech stack
javacpp
Domain
backenddeveloper experience
Issue type
bug
DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.
4
Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.
half day
Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.
active
ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.
clear
Prerequisites
Understanding of C++ virtual functionsFamiliarity with JNIKnowledge of JavaCPP's virtualization mechanism
Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.
25
Research direction
Investigate the virtual function call chain as described in the issue. Consider modifying the code generation so that JavaCPP D derives from JavaCPP B when D inherits from B, or alternatively, ensure that in step 2, B::f is called explicitly to avoid the recursion. Check the JNI callback implementation and the generated C++ source files for the virtualized classes.