static void incomplete_type_error(expression e, type t)
{
/* Avoid duplicate error message. */
if (t == error_type)
return;
if (e && is_identifier(e))
error("`%s' has an incomplete type", CAST(identifier, e)->cstring.data);
else
{
while (type_array(t) && type_array_size(t))
t = type_array_of(t);
if (type_struct(t))
error("invalid use of undefined type `struct %s'", type_tag(t)->name);
else if (type_union(t))
error("invalid use of undefined type `union %s'", type_tag(t)->name);
else if (type_enum(t))
error("invalid use of undefined type `enum %s'", type_tag(t)->name);
else if (type_void(t))
error("invalid use of void expression");
else if (type_array(t))
error("invalid use of array with unspecified bounds");
else
assert(0);
/* XXX: Missing special message for typedef's */
}
}
type default_conversion_for_assignment(expression e)
{
if (type_array(e->type) || type_function(e->type))
return default_conversion(e);
else
return e->type;
}
static inline address _KNI_GetRawArrayRegion_start_address(jarray src,
jsize offset) {
TypeArray::Raw type_array = kni_read_handle(src);
GUARANTEE(type_array.not_null(), "null arg to KNI_[Get|Set]RawArrayRegion");
address ta_start =
(address)&((char*)type_array.obj())[type_array().base_offset() + offset];
return (ta_start);
}
static bool check_writable_lvalue(expression e, char *context)
{
if (!e->lvalue || type_array(e->type))
{
error("invalid lvalue in %s", context);
return FALSE;
}
if (type_readonly(e->type))
readonly_warning(e, context);
return TRUE;
}
type default_conversion(expression e)
{
type from = e->type;
if (type_enum(from))
from = type_tag(from)->reptype;
if (type_smallerthanint(from))
{
/* Traditionally, unsignedness is preserved in default promotions. */
if (flag_traditional && type_unsigned(from))
return unsigned_int_type;
else
return int_type;
}
if (flag_traditional && !flag_allow_single_precision && type_float(from))
return double_type;
if (type_void(from))
{
error("void value not ignored as it ought to be");
return error_type;
}
if (type_function(from))
{
assert(!e->cst);
e->cst = e->static_address;
return make_pointer_type(from);
}
if (type_array(from))
{
if (!e->lvalue)
{
error("invalid use of non-lvalue array");
return error_type;
}
assert(!e->cst);
e->cst = e->static_address;
/* It's being used as a pointer, so is not an lvalue */
e->lvalue = FALSE;
return make_pointer_type(type_array_of(from));
}
return from;
}
// Callback
void objectDetect::imageCallback(const sensor_msgs::ImageConstPtr& img)
{
// transform image
cv_bridge::CvImagePtr cv_image = cv_bridge::toCvCopy(img, sensor_msgs::image_encodings::BGR8);
cv::Mat image = cv_image->image;
std::vector<cv::LatentSvmDetector::ObjectDetection> detections;
// detection main
#if defined(HAS_GPU)
if (use_gpu) {
gpu_detector_->detect(image, detections, (float)overlap_threshold_, num_threads_,
lambda_, num_cells_, (float)val_of_truncate_);
} else {
#endif
cpu_detector_->detect(image, detections, (float)overlap_threshold_, num_threads_,
score_threshold_, lambda_, num_cells_, num_bins_);
#if defined(HAS_GPU)
}
#endif
int num = detections.size();
std::vector<int> corner_point_array(num * 4.0);
std::vector<int> type_array(num, 0);
cv_tracker::image_obj msg;
msg.header = img->header;
msg.type = object_class;
for(size_t i = 0; i < detections.size(); i++)
{
const cv::LatentSvmDetector::ObjectDetection& od = detections[i];
cv_tracker::image_rect rect;
type_array[i] = od.classID;
rect.x = od.rect.x;
rect.y = od.rect.y;
rect.width = od.rect.width;
rect.height = od.rect.height;
rect.score = od.score;
msg.obj.push_back(rect);
}
detect_pub_.publish(msg);
}
expression make_comma(location loc, expression elist)
{
expression result = CAST(expression, new_comma(parse_region, loc, elist));
expression e;
scan_expression (e, elist)
if (e->next) /* Not last */
{
#if 0
if (!e->side_effects)
{
/* The left-hand operand of a comma expression is like an expression
statement: with -W or -Wunused, we should warn if it doesn't have
any side-effects, unless it was explicitly cast to (void). */
if ((extra_warnings || warn_unused)
&& !(TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
&& TREE_TYPE (TREE_VALUE (list)) == void_type_node))
warning ("left-hand operand of comma expression has no effect");
}
else if (warn_unused)
warn_if_unused_value(e);
#endif
}
else
{
if (type_array(e->type))
result->type = default_conversion(e);
else
result->type = e->type;
if (!pedantic)
{
/* XXX: I seemed to believe that , could be a constant expr in GCC,
but cst3.c seems to disagree. Check gcc code again ?
(It's a bad idea anyway) */
result->lvalue = e->lvalue;
result->isregister = e->isregister;
result->bitfield = e->bitfield;
}
}
return result;
}
/* Declare a new temporary that can be assigned a value of type t.
Place the declaration at the start of block.
XXX: See discussion in types.c:tag2ast about the (lack of) correctness of
this approach.
Return it's declaration */
data_decl build_declaration(region r, struct environment *e,
type t, const char *name, expression init,
data_declaration *oddecl)
{
struct data_declaration tempdecl;
identifier_declarator id;
variable_decl vd;
data_decl dd;
declarator tdeclarator;
type_element tmodifiers;
/* Compute real type, name */
if (type_array(t))
t = make_pointer_type(type_array_of(t));
else if (type_function(t))
t = make_pointer_type(t);
/* Qualifiers must not be present on the temp (the qualifiers of t apply
to the original location we are building a temp) */
t = make_qualified_type(t, no_qualifiers);
/* Build AST for the declaration */
id = new_identifier_declarator(r, dummy_location, str2cstring(r, name));
type2ast(r, dummy_location, t, CAST(declarator, id), &tdeclarator, &tmodifiers);
vd = new_variable_decl(r, dummy_location, tdeclarator, NULL, init, NULL, NULL);
vd->declared_type = t;
dd = new_data_decl(r, dummy_location, tmodifiers, CAST(declaration, vd));
if (e) /* Declare the variable */
{
init_data_declaration(&tempdecl, CAST(declaration, vd), id->cstring.data, t);
tempdecl.kind = decl_variable;
tempdecl.vtype = variable_normal;
tempdecl.islocal = TRUE;
*oddecl = vd->ddecl = declare(e, &tempdecl, FALSE);
}
return dd;
}
static void dump_fields(region r, const char *prefix, field_declaration fields)
{
while (fields)
{
if (fields->name) /* skip anon fields */
{
type t = fields->type;
printf(" %s%s ", prefix, fields->name);
while (type_array(t))
{
type base = type_array_of(t);
expression size = type_array_size(t);
printf("[%lu]", (unsigned long)constant_uint_value(size->cst));
t = base;
}
dump_type(t);
assert(cval_isinteger(fields->offset));
printf(" %lu %lu\n", (unsigned long)cval_uint_value(fields->offset),
(unsigned long)
(!cval_istop(fields->bitwidth) ?
cval_uint_value(fields->bitwidth) :
BITSPERBYTE * cval_uint_value(type_size(t))));
if (type_aggregate(t))
{
tag_declaration tdecl = type_tag(t);
char *newprefix = rarrayalloc(r, strlen(prefix) + strlen(fields->name) + 2, char);
sprintf(newprefix, "%s%s.", prefix, fields->name);
dump_fields(r, newprefix, tdecl->fieldlist);
printf(" %s%s AX\n", prefix, fields->name);
}
}
fields = fields->next;
}
KNIEXPORT void KNI_SetDoubleArrayElement(jdoubleArray arrayHandle,
jsize index, jdouble value) {
TypeArray::Raw type_array = kni_read_handle(arrayHandle);
GUARANTEE(type_array.not_null(), "null arg to KNI_SetDoubleArrayElement");
type_array().double_at_put(index, value);
}
KNIEXPORT jdouble
KNI_GetDoubleArrayElement(jdoubleArray arrayHandle, jsize index) {
TypeArray::Raw type_array = kni_read_handle(arrayHandle);
GUARANTEE(type_array.not_null(), "null arg to KNI_GetDoubleArrayElement");
return type_array().double_at(index);
}
KNIEXPORT jboolean
KNI_GetBooleanArrayElement(jbooleanArray arrayHandle, jsize index) {
TypeArray::Raw type_array = kni_read_handle(arrayHandle);
GUARANTEE(type_array.not_null(), "null arg to KNI_GetBooleanArrayElement");
return type_array().bool_at(index);
}
void *LLVMFormula::emit (CallExprAST *expr)
{
// Deal with the if-instruction first, specially
if (expr->function == "if")
{
Value *cond = (Value *)expr->args[0]->generate (this);
Value *t = (Value *)expr->args[1]->generate (this);
Value *f = (Value *)expr->args[2]->generate (this);
if (cond == NULL || t == NULL || f == NULL) return NULL;
Value *one = ConstantFP::get (getGlobalContext (), APFloat (1.0));
Value *cmp = builder->CreateFCmpOEQ (cond, one, "ifcmptmp");
return builder->CreateSelect (cmp, t, f, "ifelsetmp");
}
// Sign isn't a standard-library function, implement it with a compare
if (expr->function == "sign")
{
Value *v = (Value *)expr->args[0]->generate (this);
if (!v) return NULL;
Value *zero = ConstantFP::get (getGlobalContext (), APFloat (0.0));
Value *one = ConstantFP::get (getGlobalContext (), APFloat (1.0));
Value *none = ConstantFP::get (getGlobalContext (), APFloat (-1.0));
Value *cmpgzero = builder->CreateFCmpOGT (v, zero, "sgncmpgzero");
Value *cmplzero = builder->CreateFCmpOLT (v, zero, "sgncmplzero");
Value *fselect = builder->CreateSelect (cmplzero, none, zero, "sgnsellzero");
return builder->CreateSelect (cmpgzero, one, fselect, "sgnselgzero");
}
//
// Map our function names to standard libm names
//
// If we're calling "log", we want "log10"
if (expr->function == "log")
expr->function = "log10";
// If we're calling "ln", we want "log"
if (expr->function == "ln")
expr->function = "log";
// If we're calling "abs", we want "fabs"
if (expr->function == "abs")
expr->function = "fabs";
// The following are available as LLVM intrinsics, and we should emit them
// specially without calling out to libm:
Intrinsic::ID intrinsicID = Intrinsic::not_intrinsic;
if (expr->function == "cos")
intrinsicID = Intrinsic::cos;
else if (expr->function == "exp")
intrinsicID = Intrinsic::exp;
else if (expr->function == "log")
intrinsicID = Intrinsic::log;
else if (expr->function == "log10")
intrinsicID = Intrinsic::log10;
else if (expr->function == "sin")
intrinsicID = Intrinsic::sin;
else if (expr->function == "sqrt")
intrinsicID = Intrinsic::sqrt;
if (intrinsicID != Intrinsic::not_intrinsic)
{
// Most of the floating-point intrinsics are overloaded for multiple types
Type *types[1] = { Type::getDoubleTy (getGlobalContext ()) };
ArrayRef<Type *> type_array(types, 1);
Value *arg = (Value *)expr->args[0]->generate (this);
if (!arg) return NULL;
Value *func = Intrinsic::getDeclaration (module, intrinsicID, type_array);
return builder->CreateCall (func, arg, expr->function);
}
// The rest of these are calls to stdlib floating point math
// functions.
// atan2 is special, because it has two arguments
if (expr->function == "atan2")
{
Value *arg1 = (Value *)expr->args[0]->generate (this);
Value *arg2 = (Value *)expr->args[1]->generate (this);
if (!arg1 || !arg2) return NULL;
Module *M = builder->GetInsertBlock ()->getParent ()->getParent ();
Value *Callee = M->getOrInsertFunction (expr->function,
Type::getDoubleTy (getGlobalContext ()),
Type::getDoubleTy (getGlobalContext ()),
Type::getDoubleTy (getGlobalContext ()),
NULL);
return builder->CreateCall2 (Callee, arg1, arg2, expr->function);
}
else
{
// Emit a call to function (arg)
Value *arg = (Value *)expr->args[0]->generate (this);
if (!arg) return NULL;
Module *M = builder->GetInsertBlock ()->getParent ()->getParent ();
Value *Callee = M->getOrInsertFunction (expr->function,
Type::getDoubleTy (getGlobalContext ()),
Type::getDoubleTy (getGlobalContext ()),
NULL);
return builder->CreateCall (Callee, arg, expr->function);
}
}
void *LLVMFormula::emit (BinaryExprAST *expr)
{
if (expr->op == "=")
{
// The assign function has to be dealt with specially, we *do not*
// want to emit the LHS code (the load-from-memory instruction)!
VariableExprAST *var = dynamic_cast<VariableExprAST *>(expr->LHS);
if (!var) return NULL;
Value *val = (Value *)expr->RHS->generate (this);
if (!val) return NULL;
// Emit a store-to-pointer instruction
builder->CreateStore (val, getGlobalVariableFor (var->pointer), "storetmp");
return val;
}
// The rest of the operators function normally
Value *L = (Value *)expr->LHS->generate (this);
Value *R = (Value *)expr->RHS->generate (this);
if (L == NULL || R == NULL) return NULL;
if (expr->op == "<=")
{
L = builder->CreateFCmpULE (L, R, "letmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == ">=")
{
L = builder->CreateFCmpUGE (L, R, "getmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == "!=")
{
L = builder->CreateFCmpUNE (L, R, "neqtmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == "==")
{
L = builder->CreateFCmpUEQ (L, R, "eqtmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == "<")
{
L = builder->CreateFCmpULT (L, R, "lttmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == ">")
{
L = builder->CreateFCmpUGT (L, R, "gttmp");
return builder->CreateUIToFP (L, Type::getDoubleTy (getGlobalContext ()),
"booltmp");
}
else if (expr->op == "+")
return builder->CreateFAdd (L, R, "addtmp");
else if (expr->op == "-")
return builder->CreateFSub (L, R, "subtmp");
else if (expr->op == "*")
return builder->CreateFMul (L, R, "multmp");
else if (expr->op == "/")
return builder->CreateFDiv (L, R, "divtmp");
else if (expr->op == "^")
{
// The floating-point intrinsics are overloaded for multiple types
Type *types[1] = { Type::getDoubleTy (getGlobalContext ()) };
ArrayRef<Type *> type_array(types, 1);
Value *func = Intrinsic::getDeclaration (module, Intrinsic::pow, type_array);
return builder->CreateCall2 (func, L, R, "pow");
}
else
return NULL;
}
expression make_cast(location loc, asttype t, expression e)
{
expression result = CAST(expression, new_cast(parse_region, loc, e, t));
type castto = t->type;
if (castto == error_type || type_void(castto))
; /* Do nothing */
else if (type_array(castto))
{
error("cast specifies array type");
castto = error_type;
}
else if (type_function(castto))
{
error("cast specifies function type");
castto = error_type;
}
else if (type_equal_unqualified(castto, e->type))
{
if (pedantic && type_aggregate(castto))
pedwarn("ANSI C forbids casting nonscalar to the same type");
}
else
{
type etype = e->type;
/* Convert functions and arrays to pointers,
but don't convert any other types. */
if (type_function(etype) || type_array(etype))
etype = default_conversion(e);
if (type_union(castto))
{
tag_declaration utag = type_tag(castto);
field_declaration ufield;
/* Look for etype as a field of the union */
for (ufield = utag->fieldlist; ufield; ufield = ufield->next)
if (ufield->name && type_equal_unqualified(ufield->type, etype))
{
if (pedantic)
pedwarn("ANSI C forbids casts to union type");
break;
}
if (!ufield)
error("cast to union type from type not present in union");
}
else
{
/* Optionally warn about potentially worrisome casts. */
if (warn_cast_qual && type_pointer(etype) && type_pointer(castto))
{
type ep = type_points_to(etype), cp = type_points_to(castto);
if (type_volatile(ep) && !type_volatile(cp))
pedwarn("cast discards `volatile' from pointer target type");
if (type_const(ep) && !type_const(cp))
pedwarn("cast discards `const' from pointer target type");
}
/* This warning is weird */
if (warn_bad_function_cast && is_function_call(e) &&
!type_equal_unqualified(castto, etype))
warning ("cast does not match function type");
#if 0
/* Warn about possible alignment problems. */
if (STRICT_ALIGNMENT && warn_cast_align
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
/* Don't warn about opaque types, where the actual alignment
restriction is unknown. */
&& !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
|| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
&& TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
warning ("cast increases required alignment of target type");
if (TREE_CODE (type) == INTEGER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
&& !TREE_CONSTANT (value))
warning ("cast from pointer to integer of different size");
if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == INTEGER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
#if 0
/* Don't warn about converting 0 to pointer,
provided the 0 was explicit--not cast or made by folding. */
&& !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
#endif
/* Don't warn about converting any constant. */
&& !TREE_CONSTANT (value))
warning ("cast to pointer from integer of different size");
#endif
check_conversion(castto, etype);
}
}
result->lvalue = !pedantic && e->lvalue;
result->isregister = e->isregister;
result->bitfield = e->bitfield;
result->static_address = e->static_address;
result->type = castto;
result->cst = fold_cast(result);
return result;
}
