Question

GnuCOBOL编译器通过使用动态符号查找来支持动态CALL，但这里的MCVE严格来说是C，并且稍微小于最小值来演示（我认为）4和8字节大小都在工作。

这是AMD-64，因此sizeof * float不等于sizeof float。

问题只有在通过dlsym查找的泛型（在本例中为unsignatured）函数指针调用时解除引用float时才会出现。

Thread dw= new Thread() {
            public void run() {
                try {
                    s = getData();
                }
                catch (Exception e) {
                    s = "Error";
                    Log.i("Error",e.toString());
                }
            }
        };

        dw.start();

运行

// gcc -Wl,--export-dynamic -g -o byval byval.c -ldl

#include <stdio.h>
#include <dlfcn.h>

// hack in a 1 / 3 float 0.303030, 1050355402 as 32bit int
unsigned char field[4] = {0xca, 0x26, 0x9b, 0x3e};

// and a 1 / 6 double, 0.151515
unsigned char dtype[8] = {0x64, 0x93, 0x4d, 0x36, 0xd9, 0x64, 0xc3, 0x3f};

int aroutine(float);

int
main(int argc, char** argv)
{

    float* fp = (float*)field;
    double g;

    void* this;
    int (*calling)();

    int result;

    /* call the routines using generic data treated as float */
    float f = *fp;
    printf("Initial: %f \n", f);

    printf("\nBy signature\n");
    result = aroutine(*(float*)(field));

    this = dlopen("", RTLD_LAZY);

    printf("\nGeneric: (busted, stack gets 0x40000000)\n");
    calling = dlsym(this, "aroutine");
    result = calling(*(float*)(field));

    printf("\nBy reference: (works when callee dereferences)\n");
    calling = dlsym(this, "proutine");
    result = calling((float*)(field));

    printf("\nGeneric double (works):\n");
    calling = dlsym(this, "droutine");
    result = calling(*(double*)(dtype));

    printf("\nGeneric int and double (works):\n");
    calling = dlsym(this, "idroutine");
    result = calling(*(int*)(field),*(double*)(dtype));

    printf("\nGeneric int and float (busted) and int:\n");
    calling = dlsym(this, "ifiroutine");
    result = calling(*(int*)(field), *(float*)(field), *(int*)(field));

    return 0;
}

int aroutine(float f) {
    printf("aroutine: %f\n", f);
    return 0;
}

int proutine(float *fp) {
    printf("proutine: %f\n", *fp);
    return 0;
}

int droutine(double g) {
    printf("droutine: %g\n", g);
    return 0;
}

int idroutine(int i, double g) {
    printf("idroutine: %d %g\n", i, g);
    return 0;
}

int ifiroutine(int i, float f, int j) {
    printf("ifiroutine: %d %f %d\n", i, f, j);
    return 0;
}

我认为我需要对64位ABI在解除引用浮动数据时处理无信号调用的方式进行一点了解。

包含COBOL标签，因为当使用带有CALL BY VALUE的FLOAT-SHORT （C float）时，这会打破GnuCOBOL （生成C中间体），而FLOAT- LONG （C double） CALL BY VALUE和32位整数一样工作。

顺便说一句，我很确定这不是gcc中的错误，因为tcc prompt$ gcc -Wl,--export-dynamic -g -o mcve stackoverflow.c -ldl prompt$ ./mcve Initial: 0.303030 By signature aroutine: 0.303030 Generic: (busted, stack gets 0x40000000) aroutine: 2.000000 By reference: (works when callee dereferences) proutine: 0.303030 Generic double (works): droutine: 0.151515 Generic int and double (works): idroutine: 1050355402 0.151515 Generic int and float (busted) and int: ifiroutine: 1050355402 2.000000 1050355402表现出相同的输出，浮动解除引用看起来很笨，所以我倾向于（和希望这是一个可以解决的问题，给出了编译器的正确语法提示，或编译时选项。

Answer 1

C99和C11 6.5.2.2p6状态

如果表示被调用函数的表达式具有不包含原型的类型，则对每个参数执行整数提升，并将类型为float的参数提升为double。这些被称为默认参数促销。

和6.5.2.2p7继续

如果表示被调用函数的表达式具有包含原型的类型，则将参数隐式转换为相应参数的类型，就像通过赋值一样，将每个参数的类型设置为不合格的版本其声明的类型。函数原型声明符中的省略号表示法导致参数类型转换在最后声明的参数之后停止。默认参数提升是在尾随参数上执行的。

因此，当您调用具有float参数的函数时，原型（＆＃34;签名＆＃34;正如您所说）会告诉编译器不转换float到double。（类似于小于int的整数类型。）

显然，修复是使用原型（＆＃34;签名＆＃34;）。如果您想传递float，char或short，则必须，因为如果没有原型，它们会被提升为{{分别为1}}，double和int。

然而，这应该不是负担。如果您有一些无原型函数指针，请说

int

并且你想调用一个原型是int (*generic)() = dlsym(self, "aroutine");的函数，你总是可以转换函数指针：

void foo(float, int, double)

虽然使用带有正确原型的临时函数指针肯定更容易阅读和维护：

((void (*)(float, int, double))generic)(f_arg, i_arg, d_arg);

请参阅POSIX dlsym() documentation以供参考。（不再推荐older versions中推荐的{ void (*call_foo)(float, int, double) = (void *)generic; call_foo(f_arg, i_arg, d_arg); }成语;无论如何，这都是愚蠢的。）

来自dlsym的通用函数，带有dereferenced float

1 个答案: