void
BackendLLVM::llvm_assign_initial_value (const Symbol& sym)
{
// Don't write over connections! Connection values are written into
// our layer when the earlier layer is run, as part of its code. So
// we just don't need to initialize it here at all.
if (sym.valuesource() == Symbol::ConnectedVal &&
!sym.typespec().is_closure_based())
return;
if (sym.typespec().is_closure_based() && sym.symtype() == SymTypeGlobal)
return;
int arraylen = std::max (1, sym.typespec().arraylength());
// Closures need to get their storage before anything can be
// assigned to them. Unless they are params, in which case we took
// care of it in the group entry point.
if (sym.typespec().is_closure_based() &&
sym.symtype() != SymTypeParam && sym.symtype() != SymTypeOutputParam) {
llvm_assign_zero (sym);
return;
}
if ((sym.symtype() == SymTypeLocal || sym.symtype() == SymTypeTemp)
&& shadingsys().debug_uninit()) {
// Handle the "debug uninitialized values" case
bool isarray = sym.typespec().is_array();
int alen = isarray ? sym.typespec().arraylength() : 1;
llvm::Value *u = NULL;
if (sym.typespec().is_closure_based()) {
// skip closures
}
else if (sym.typespec().is_floatbased())
u = ll.constant (std::numeric_limits<float>::quiet_NaN());
else if (sym.typespec().is_int_based())
u = ll.constant (std::numeric_limits<int>::min());
else if (sym.typespec().is_string_based())
u = ll.constant (Strings::uninitialized_string);
if (u) {
for (int a = 0; a < alen; ++a) {
llvm::Value *aval = isarray ? ll.constant(a) : NULL;
for (int c = 0; c < (int)sym.typespec().aggregate(); ++c)
llvm_store_value (u, sym, 0, aval, c);
}
}
return;
}
if ((sym.symtype() == SymTypeLocal || sym.symtype() == SymTypeTemp) &&
sym.typespec().is_string_based()) {
// Strings are pointers. Can't take any chance on leaving
// local/tmp syms uninitialized.
llvm_assign_zero (sym);
return; // we're done, the parts below are just for params
}
ASSERT_MSG (sym.symtype() == SymTypeParam || sym.symtype() == SymTypeOutputParam,
"symtype was %d, data type was %s", (int)sym.symtype(), sym.typespec().c_str());
if (sym.has_init_ops() && sym.valuesource() == Symbol::DefaultVal) {
// Handle init ops.
build_llvm_code (sym.initbegin(), sym.initend());
} else if (! sym.lockgeom() && ! sym.typespec().is_closure()) {
// geometrically-varying param; memcpy its default value
TypeDesc t = sym.typespec().simpletype();
ll.op_memcpy (llvm_void_ptr (sym), ll.constant_ptr (sym.data()),
t.size(), t.basesize() /*align*/);
if (sym.has_derivs())
llvm_zero_derivs (sym);
} else {
// Use default value
int num_components = sym.typespec().simpletype().aggregate;
TypeSpec elemtype = sym.typespec().elementtype();
for (int a = 0, c = 0; a < arraylen; ++a) {
llvm::Value *arrind = sym.typespec().is_array() ? ll.constant(a) : NULL;
if (sym.typespec().is_closure_based())
continue;
for (int i = 0; i < num_components; ++i, ++c) {
// Fill in the constant val
llvm::Value* init_val = 0;
if (elemtype.is_floatbased())
init_val = ll.constant (((float*)sym.data())[c]);
else if (elemtype.is_string())
init_val = ll.constant (((ustring*)sym.data())[c]);
else if (elemtype.is_int())
init_val = ll.constant (((int*)sym.data())[c]);
ASSERT (init_val);
llvm_store_value (init_val, sym, 0, arrind, i);
}
}
if (sym.has_derivs())
llvm_zero_derivs (sym);
}
// Handle interpolated params.
// FIXME -- really, we shouldn't assign defaults or run init ops if
// the values are interpolated. The perf hit is probably small, since
// there are so few interpolated params, but we should come back and
// fix this later.
if ((sym.symtype() == SymTypeParam || sym.symtype() == SymTypeOutputParam)
&& ! sym.lockgeom()) {
std::vector<llvm::Value*> args;
args.push_back (sg_void_ptr());
args.push_back (ll.constant (sym.name()));
args.push_back (ll.constant (sym.typespec().simpletype()));
args.push_back (ll.constant ((int) sym.has_derivs()));
args.push_back (llvm_void_ptr (sym));
ll.call_function ("osl_bind_interpolated_param",
&args[0], args.size());
}
}
void
RuntimeOptimizer::llvm_assign_initial_value (const Symbol& sym)
{
// Don't write over connections! Connection values are written into
// our layer when the earlier layer is run, as part of its code. So
// we just don't need to initialize it here at all.
if (sym.valuesource() == Symbol::ConnectedVal &&
!sym.typespec().is_closure_based())
return;
if (sym.typespec().is_closure_based() && sym.symtype() == SymTypeGlobal)
return;
int arraylen = std::max (1, sym.typespec().arraylength());
// Closures need to get their storage before anything can be
// assigned to them. Unless they are params, in which case we took
// care of it in the group entry point.
if (sym.typespec().is_closure_based() &&
sym.symtype() != SymTypeParam && sym.symtype() != SymTypeOutputParam) {
llvm_assign_zero (sym);
}
if (sym.symtype() != SymTypeParam && sym.symtype() != SymTypeOutputParam &&
sym.symtype() != SymTypeConst && sym.typespec().is_string_based()) {
// Strings are pointers. Can't take any chance on leaving local/tmp
// syms uninitialized.
DASSERT (sym.symtype() == SymTypeLocal || sym.symtype() == SymTypeTemp);
llvm_assign_zero (sym);
return; // we're done, the parts below are just for params
}
if (sym.has_init_ops() && sym.valuesource() == Symbol::DefaultVal) {
// Handle init ops.
build_llvm_code (sym.initbegin(), sym.initend());
} else {
// Use default value
int num_components = sym.typespec().simpletype().aggregate;
for (int a = 0, c = 0; a < arraylen; ++a) {
llvm::Value *arrind = sym.typespec().is_array() ? llvm_constant(a) : NULL;
if (sym.typespec().is_closure_based())
continue;
for (int i = 0; i < num_components; ++i, ++c) {
// Fill in the constant val
llvm::Value* init_val = 0;
TypeSpec elemtype = sym.typespec().elementtype();
if (elemtype.is_floatbased())
init_val = llvm_constant (((float*)sym.data())[c]);
else if (elemtype.is_string())
init_val = llvm_constant (((ustring*)sym.data())[c]);
else if (elemtype.is_int())
init_val = llvm_constant (((int*)sym.data())[c]);
ASSERT (init_val);
llvm_store_value (init_val, sym, 0, arrind, i);
}
}
if (sym.has_derivs())
llvm_zero_derivs (sym);
}
// Handle interpolated params.
// FIXME -- really, we shouldn't assign defaults or run init ops if
// the values are interpolated. The perf hit is probably small, since
// there are so few interpolated params, but we should come back and
// fix this later.
if ((sym.symtype() == SymTypeParam || sym.symtype() == SymTypeOutputParam)
&& ! sym.lockgeom()) {
std::vector<llvm::Value*> args;
args.push_back (sg_void_ptr());
args.push_back (llvm_constant (sym.name()));
args.push_back (llvm_constant (sym.typespec().simpletype()));
args.push_back (llvm_constant ((int) sym.has_derivs()));
args.push_back (llvm_void_ptr (sym));
llvm_call_function ("osl_bind_interpolated_param",
&args[0], args.size());
}
}
