The reason of problem is that ISPC generates debugInfo type of struct (or enum)
in the scope, where the variable of this type appears.
Ctx.cpp:1586
llvm::DIScope scope = GetDIScope();
llvm::DIType diType = sym->type->GetDIType(scope);
It is always Lexical_Block in some function. It is not right because type can
be declared global or in some function or in some namespace. Struct and enums
are failing because they don't reduce to atomic types. The "Big" fix is to save
declaration place in Type class. But now ISPC doesn't know about it,
for example this doesn't emit an error:
void function_1() { struct Foo {float x;}; uniform Foo myFoo;}
void function_2() { uniform Foo myFoo;}
So now all type declarations are global and we can simply change scope
parameter to the current file.
The "Big" fix will be after integration with clang.
We can now do constant folding with all basic datatypes (the previous
implementation handled int32 well, but had limited, if any, coverage
for other datatypes.)
Reduced a bit of repeated code in the constant folding implementation
through template helper functions.
Previously, GetElementType() would end up causing dynamic allocation to
happen to compute the final element type (turning types with unbound
variability into the same type with the struct's variability) each it was
called, which was wasteful and slow. Now we cache the result.
Another 20% perf on compiling that problematic program.
We don't need to explicitly create the non-const Types to do type
comparison when ignoring const-ness in the check.
We can also save some unnecessary dynamic memory allocation by
keeping strings returned from GetStructName() as references to strings.
This gives another 10% on front-end perf on that big program.
We now have a set of template functions CastType<AtomicType>, etc., that in
turn use a new typeId field in each Type instance, allowing them to be inlined
and to be quite efficient.
This improves front-end performance for a particular large program by 28%.
