llvm::Value* Executor::codegenArrayAt(const Analyzer::BinOper* array_at, const CompilationOptions& co) {
const auto arr_expr = array_at->get_left_operand();
const auto idx_expr = array_at->get_right_operand();
const auto& idx_ti = idx_expr->get_type_info();
CHECK(idx_ti.is_integer());
auto idx_lvs = codegen(idx_expr, true, co);
CHECK_EQ(size_t(1), idx_lvs.size());
auto idx_lv = idx_lvs.front();
if (idx_ti.get_logical_size() < 8) {
idx_lv = cgen_state_->ir_builder_.CreateCast(
llvm::Instruction::CastOps::SExt, idx_lv, get_int_type(64, cgen_state_->context_));
}
const auto& array_ti = arr_expr->get_type_info();
CHECK(array_ti.is_array());
const auto& elem_ti = array_ti.get_elem_type();
const std::string array_at_fname{
elem_ti.is_fp() ? "array_at_" + std::string(elem_ti.get_type() == kDOUBLE ? "double_checked" : "float_checked")
: "array_at_int" + std::to_string(elem_ti.get_logical_size() * 8) + "_t_checked"};
const auto ret_ty = elem_ti.is_fp() ? (elem_ti.get_type() == kDOUBLE ? llvm::Type::getDoubleTy(cgen_state_->context_)
: llvm::Type::getFloatTy(cgen_state_->context_))
: get_int_type(elem_ti.get_logical_size() * 8, cgen_state_->context_);
const auto arr_lvs = codegen(arr_expr, true, co);
CHECK_EQ(size_t(1), arr_lvs.size());
return cgen_state_->emitExternalCall(array_at_fname,
ret_ty,
{arr_lvs.front(),
posArg(arr_expr),
idx_lv,
elem_ti.is_fp() ? static_cast<llvm::Value*>(inlineFpNull(elem_ti))
: static_cast<llvm::Value*>(inlineIntNull(elem_ti))});
}
static int get_type_tag(Symbol * type, DWORD * tag) {
DWORD dword;
for (;;) {
if (get_type_info(type, TI_GET_SYMTAG, &dword) < 0) return -1;
if (dword != SymTagTypedef && dword != SymTagFunction && dword != SymTagData) break;
if (get_type_info(type, TI_GET_TYPE, &dword) < 0) return -1;
type->index = dword;
}
type->sym_class = SYM_CLASS_TYPE;
*tag = dword;
return 0;
}
static void tag2symclass(Symbol * sym, int tag) {
DWORD dword;
sym->sym_class = SYM_CLASS_UNKNOWN;
switch (tag) {
case SymTagFunction:
sym->sym_class = SYM_CLASS_FUNCTION;
break;
case SymTagData:
if (get_type_info(sym, TI_GET_DATAKIND, &dword) == 0) {
if (dword == DataIsConstant) {
sym->sym_class = SYM_CLASS_VALUE;
break;
}
}
sym->sym_class = SYM_CLASS_REFERENCE;
break;
case SymTagUDT:
case SymTagEnum:
case SymTagFunctionType:
case SymTagPointerType:
case SymTagArrayType:
case SymTagBaseType:
case SymTagTypedef:
case SymTagBaseClass:
case SymTagFunctionArgType:
case SymTagCustomType:
case SymTagManagedType:
sym->sym_class = SYM_CLASS_TYPE;
break;
}
}
ChaiScriptScript::ChaiScriptScript(std::string const& path)
: chai_(
std::make_unique<chaiscript::ChaiScript>(chaiscript::Std_Lib::library()))
{
InitializeChaiScriptContext(*chai_, true);
auto& log = GetImGuiLogWindow();
try
{
auto const val = chai_->eval_file(path.c_str());
if (!val.get_type_info().bare_equal(chaiscript::user_type<void>()))
{
try
{
auto const str = chai_->eval<
std::function<std::string(const chaiscript::Boxed_Value& bv)>>(
"to_string")(val);
HADESMEM_DETAIL_TRACE_FORMAT_A("[Info]: %s.", str.c_str());
log.AddLog("[Info]: %s\n", str.c_str());
}
catch (...)
{
}
}
chai_->eval("CerberusScriptStart()");
}
catch (const chaiscript::exception::eval_error& ee)
{
if (ee.call_stack.size() > 0)
{
HADESMEM_DETAIL_TRACE_FORMAT_A(
"[Error]: %s during evaluation at (%d,%d).",
boost::current_exception_diagnostic_information().c_str(),
ee.call_stack[0]->start().line,
ee.call_stack[0]->start().column);
log.AddLog("[Error]: %s during evaluation at (%d,%d)\n",
boost::current_exception_diagnostic_information().c_str(),
ee.call_stack[0]->start().line,
ee.call_stack[0]->start().column);
}
else
{
HADESMEM_DETAIL_TRACE_FORMAT_A(
"[Error]: %s.",
boost::current_exception_diagnostic_information().c_str());
log.AddLog("[Error]: %s\n",
boost::current_exception_diagnostic_information().c_str());
}
}
catch (...)
{
HADESMEM_DETAIL_TRACE_FORMAT_A(
"[Error]: %s.",
boost::current_exception_diagnostic_information().c_str());
log.AddLog("[Error]: %s\n",
boost::current_exception_diagnostic_information().c_str());
}
}
int get_symbol_index_type(const Symbol * sym, Symbol ** type) {
DWORD tag = 0;
DWORD index = 0;
Symbol * res = alloc_symbol();
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
res->ctx = sym->ctx;
res->sym_class = SYM_CLASS_TYPE;
res->info = basic_type_info + BST_UNSIGNED;
assert(res->info->size == sizeof(int));
assert(res->info->sign == 0);
assert(res->info->real == 0);
*type = res;
return 0;
}
if (sym->info) {
errno = ERR_INV_CONTEXT;
return -1;
}
*res = *sym;
if (get_type_tag(res, &tag)) return -1;
if (get_type_info(res, TI_GET_ARRAYINDEXTYPEID, &index) < 0) return -1;
res->index = index;
*type = res;
return 0;
}
int id2symbol(const char * id, Symbol ** res) {
Symbol * sym = NULL;
Context * ctx = NULL;
ULONG64 module = 0;
ULONG index = 0;
unsigned frame = 0;
const Symbol * base = NULL;
const TypeInfo * info = NULL;
size_t length = 0;
const char * p;
if (id != NULL && id[0] == '@' && id[1] == 'P') {
p = id + 2;
length = (size_t)read_hex(&p);
if (*p == '.') p++;
if (id2symbol(p, (Symbol **)&base)) return -1;
ctx = base->ctx;
}
else if (id != NULL && id[0] == '@' && id[1] == 'S') {
unsigned idx = 0;
p = id + 2;
module = (ULONG64)read_hex(&p);
if (*p == '.') p++;
index = (ULONG)read_hex(&p);
if (*p == '.') p++;
frame = (unsigned)read_hex(&p);
if (*p == '.') p++;
idx = (unsigned)read_hex(&p);
if (idx) info = basic_type_info + (idx - 1);
if (*p == '.') p++;
ctx = id2ctx(p);
}
else {
errno = ERR_INV_CONTEXT;
return -1;
}
if (ctx == NULL) {
errno = ERR_INV_CONTEXT;
return -1;
}
sym = alloc_symbol();
sym->ctx = ctx;
sym->module = module;
sym->index = index;
sym->frame = frame;
sym->base = base;
sym->info = info;
sym->length = length;
if (sym->base || sym->info) {
sym->sym_class = SYM_CLASS_TYPE;
}
else {
DWORD dword = 0;
if (get_type_info(sym, TI_GET_SYMTAG, &dword) < 0) return -1;
tag2symclass(sym, dword);
}
*res = sym;
return 0;
}
int get_symbol_children(const Symbol * sym, Symbol *** children, int * count) {
static const DWORD FINDCHILDREN_BUF_SIZE = 64;
static TI_FINDCHILDREN_PARAMS * params = NULL;
static Symbol ** buf = NULL;
static unsigned buf_len = 0;
DWORD cnt = 0;
Symbol type = *sym;
DWORD tag = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base || sym->info) {
*children = NULL;
*count = 0;
return 0;
}
if (get_type_tag(&type, &tag)) return -1;
if (get_type_info(&type, TI_GET_CHILDRENCOUNT, &cnt) < 0) return -1;
if (params == NULL) params = (TI_FINDCHILDREN_PARAMS *)loc_alloc(
sizeof(TI_FINDCHILDREN_PARAMS) + (FINDCHILDREN_BUF_SIZE - 1) * sizeof(ULONG));
if (buf_len < cnt) {
buf = (Symbol **)loc_realloc(buf, sizeof(Symbol *) * cnt);
buf_len = cnt;
}
params->Start = 0;
while (params->Start < cnt) {
DWORD i = cnt - (DWORD)params->Start;
params->Count = i > FINDCHILDREN_BUF_SIZE ? FINDCHILDREN_BUF_SIZE : i;
if (get_type_info(&type, TI_FINDCHILDREN, params) < 0) return -1;
for (i = 0; params->Start < cnt; i++) {
DWORD dword = 0;
Symbol * x = alloc_symbol();
*x = *sym;
x->index = params->ChildId[i];
if (get_type_info(x, TI_GET_SYMTAG, &dword) < 0) return -1;
tag2symclass(x, dword);
buf[params->Start++] = x;
}
}
*children = buf;
*count = cnt;
return 0;
}
CachedWidget::CachedWidget() : m_render_content(false) {
m_target = 0;
m_replaced_layer = new MyGUI::LayerNode(0,0);
m_texture_name = get_type_info()->name;
char buf[128];
sb::snprintf(buf, 128, "_%p", this);
m_texture_name += buf;
m_suboffset = Sandbox::Vector2f(0,0);
}
// static btw.
void
http_server::__di_register_services(ioc::container_shared_ptr_t container)
{
logtrace << "HEY! that's module-http-server __di_register_services() ;- Hura!";
typedef ioc::definition<http_server> server_service_t;
auto http_server_service = std::make_shared<server_service_t>("http.server");
logtrace << "http_server_service type name : " << http_server_service->get_type_info().pretty_name();
// Declare the FACTORY functor :
http_server_service->set_factory_function(
[](ioc::base_definition::dependencies_map_ref deps) -> http_server_ptr_t {
logtrace << "YEAH! that's service `http.server` factory functor bein' invoqued !"
" (which is quite remarkable, actually)";
try {
http_server_ptr_t server_ = std::make_shared<http_server>();
/*<< Runs the server. >>*/
//server_.run();
return server_;
}
catch (std::exception &ex) {
logfatal << "Caught exception at `http.server` service factory lambda (forwarding it).";
throw ex;
}
}
);
// Declare a STARTER functor :
#if 0
http_server_service->set_starter_function(
[](server_service_t::reference serv) -> bool {
logtrace << "YEAH! that's service `http.server` factory FUNCTOR bein' invoqued !"
" (which is also remarkable)." ;
logwarn << " » Not instanciating the cpp-netlib server (impl. stalled)";
//http_server_ptr_t server_ = serv.get_instance();
logwarn << " » Not starting the cpp-netlib server (impl. stalled)";
//server_->run();
return false;
}
);
#endif
//http_server_service->requires<SomeClassB>("world");
container->register_service( http_server_service );
}
// Function: process_setdetail
// Example: ./psmcli setdetail string COM.CISCO.CCSP.ETH0.IPv4_ADDR 192.168.100.2
unsigned int process_setdetail(int const argCnt, char const * const argVars[], char const * const busHandle) {
//printf("Command Arguments = %s\n", argVars[1]);
int cmd_index = 2;
int cmd_cnt = argCnt - 2;
unsigned int ret = 0;
unsigned int func_ret = CCSP_SUCCESS;
char *psmValue = NULL;
unsigned int psmType = ccsp_string;
char *typeStr = NULL;
char const func_name[] = "process_setdetail";
if ((cmd_cnt % 3) != 0) {
CcspTraceWarning(("<%s>[%s]: arg count = %d is not a multiple of 3, returning %d CCSP_ERR_INVALID_ARGUMENTS\n",
prog_name, func_name, cmd_cnt, CCSP_ERR_INVALID_ARGUMENTS));
return CCSP_ERR_INVALID_ARGUMENTS;
}
// setdetail shall override the current object type and set the new specified type
cmd_cnt = cmd_cnt/3;
while(cmd_cnt--) {
get_type_info(&psmType, (char**)&argVars[cmd_index], TYPE_FORMAT_STRING);
if(psmType != ccsp_none) {
ret = 0;
ret = PSM_Set_Record_Value2((void*)busHandle,
subsys_prefix, // PSMCLI_SUBSYSTEM_PREFIX,
argVars[cmd_index+1],
psmType,
argVars[cmd_index+2]);
if (ret == CCSP_SUCCESS) {
printf("%d\n", CCSP_SUCCESS);
} else {
CcspTraceWarning(("<%s>[%s]: processing setting '%s' to '%s' unsuccessful, return set to %d\n",
prog_name, func_name, argVars[cmd_index+1], argVars[cmd_index+2], ret));
func_ret = ret;
// break; // to accommondate more cmd
}
} else {
CcspTraceWarning(("<%s>[%s]: unsupported datatype '%s', return set to %d = CCSP_CR_ERR_UNSUPPORTED_DATATYPE\n",
prog_name, func_name, argVars[cmd_index], CCSP_CR_ERR_UNSUPPORTED_DATATYPE));
func_ret = CCSP_CR_ERR_UNSUPPORTED_DATATYPE;
// break; // to accommondate more cmd
}
cmd_index+=3;
}
// CcspTraceDebug(("<%s>[%s]: function finished returing %d\n", prog_name, func_name, func_ret));
return func_ret;
}
int get_symbol_offset(const Symbol * sym, ContextAddress * offset) {
DWORD dword = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base || sym->info) {
errno = ERR_INV_CONTEXT;
return -1;
}
if (get_type_info(sym, TI_GET_OFFSET, &dword) < 0) return -1;
*offset = dword;
return 0;
}
int get_symbol_flags(const Symbol * sym, SYM_FLAGS * flags) {
DWORD dword = 0;
SYMBOL_INFO * info = NULL;
*flags = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->address || sym->base || sym->info) return 0;
if (get_sym_info(sym, sym->index, &info) == 0 && (info->Flags & SYMFLAG_PARAMETER) != 0) *flags |= SYM_FLAG_PARAMETER;
if (get_type_info(sym, TI_GET_IS_REFERENCE, &dword) == 0 && dword) *flags |= SYM_FLAG_REFERENCE;
return 0;
}
int get_symbol_value(const Symbol * sym, void ** value, size_t * size, int * big_endian) {
static VARIANT data;
VARTYPE vt;
void * data_addr = &data.bVal;
size_t data_size = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base || sym->info) {
errno = ERR_INV_CONTEXT;
return -1;
}
assert(data_addr == &data.lVal);
if (get_type_info(sym, TI_GET_VALUE, &data) < 0) return -1;
vt = data.vt;
if (vt & VT_BYREF) {
data_addr = *(void **)data_addr;
vt &= ~VT_BYREF;
}
switch (vt) {
/* VOID */ case 0: break;
/* CHAR */ case VT_I1: data_size = 1; break;
/* SHORT */ case VT_I2: data_size = 2; break;
/* LONG */ case VT_I4: data_size = 4; break;
/* LONGLONG */ case VT_I8: data_size = 8; break;
/* INT */ case VT_INT: data_size = sizeof(int); break;
/* BYTE */ case VT_UI1: data_size = 1; break;
/* USHORT */ case VT_UI2: data_size = 2; break;
/* ULONG */ case VT_UI4: data_size = 4; break;
/* ULONGLONG */ case VT_UI8: data_size = 8; break;
/* UINT */ case VT_UINT: data_size = sizeof(unsigned int); break;
/* FLOAT */ case VT_R4: data_size = 4; break;
/* DOUBLE */ case VT_R8: data_size = 8; break;
/* VARIANT_BOOL */ case VT_BOOL: data_size = sizeof(BOOL); break;
/* SCODE */ case VT_ERROR: data_size = sizeof(ERROR); break;
/* CY */ case VT_CY: data_size = sizeof(CY); break;
/* DATE */ case VT_DATE: data_size = sizeof(DATE); break;
/* BSTR */ case VT_BSTR: data_size = sizeof(BSTR); break;
/* IUnknown * */ case VT_UNKNOWN: data_size = sizeof(IUnknown *); break;
/* IDispatch * */ case VT_DISPATCH: data_size = sizeof(IDispatch *); break;
/* SAFEARRAY * */ case VT_ARRAY: data_size = sizeof(SAFEARRAY *); break;
/* VARIANT */ case VT_VARIANT: data_size = sizeof(VARIANT); break;
/* DECIMAL */ case VT_DECIMAL: data_size = sizeof(DECIMAL); break;
}
*size = data_size;
*value = data_addr;
*big_endian = 0;
return 0;
}
void qd_parse_annotations(
bool strip_annotations_in,
qd_iterator_t *ma_iter_in,
qd_parsed_field_t **ma_ingress,
qd_parsed_field_t **ma_phase,
qd_parsed_field_t **ma_to_override,
qd_parsed_field_t **ma_trace,
qd_iterator_pointer_t *blob_pointer,
uint32_t *blob_item_count)
{
*ma_ingress = 0;
*ma_phase = 0;
*ma_to_override = 0;
*ma_trace = 0;
ZERO(blob_pointer);
*blob_item_count = 0;
if (!ma_iter_in)
return;
uint8_t tag = 0;
uint32_t size = 0;
uint32_t length_of_count = 0;
uint32_t length_of_size = 0;
const char *parse_error = get_type_info(ma_iter_in, &tag,
&size, blob_item_count, &length_of_size,
&length_of_count);
if (parse_error)
return;
if (!is_tag_a_map(tag)) {
return;
}
// Initial snapshot on size/content of annotation payload
qd_iterator_t *raw_iter = qd_iterator_sub(ma_iter_in, (size - length_of_count));
// If there are no router annotations then all annotations
// are the user's opaque blob.
qd_iterator_get_view_cursor(raw_iter, blob_pointer);
qd_iterator_free(raw_iter);
(void) qd_parse_annotations_v1(strip_annotations_in, ma_iter_in, ma_ingress, ma_phase,
ma_to_override, ma_trace,
blob_pointer, blob_item_count);
return;
}
int get_symbol_length(const Symbol * sym, ContextAddress * length) {
DWORD res = 0;
Symbol type = *sym;
DWORD tag = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
*length = sym->length == 0 ? 1 : sym->length;
return 0;
}
if (sym->info) {
errno = ERR_INV_CONTEXT;
return -1;
}
if (get_type_tag(&type, &tag)) return -1;
if (get_type_info(&type, TI_GET_COUNT, &res) < 0) return -1;
*length = res;
return 0;
}
int get_symbol_base_type(const Symbol * sym, Symbol ** type) {
DWORD tag = 0;
DWORD index = 0;
Symbol * res = NULL;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
*type = (Symbol *)sym->base;
return 0;
}
if (sym->info) {
errno = ERR_INV_CONTEXT;
return -1;
}
res = alloc_symbol();
*res = *sym;
if (get_type_tag(res, &tag)) return -1;
if (get_type_info(res, TI_GET_TYPE, &index) < 0) return -1;
res->index = index;
*type = res;
return 0;
}
static qd_parsed_field_t *qd_parse_internal(qd_iterator_t *iter, qd_parsed_field_t *p)
{
qd_parsed_field_t *field = new_qd_parsed_field_t();
if (!field)
return 0;
DEQ_ITEM_INIT(field);
DEQ_INIT(field->children);
field->parent = p;
field->raw_iter = 0;
field->typed_iter = qd_iterator_dup(iter);
uint32_t size = 0;
uint32_t count = 0;
uint32_t length_of_count = 0;
uint32_t length_of_size = 0;
field->parse_error = get_type_info(iter, &field->tag, &size, &count, &length_of_size, &length_of_count);
if (!field->parse_error) {
qd_iterator_trim_view(field->typed_iter, size + length_of_size + 1); // + 1 accounts for the tag length
field->raw_iter = qd_iterator_sub(iter, size - length_of_count);
qd_iterator_advance(iter, size - length_of_count);
for (uint32_t idx = 0; idx < count; idx++) {
qd_parsed_field_t *child = qd_parse_internal(field->raw_iter, field);
DEQ_INSERT_TAIL(field->children, child);
if (!qd_parse_ok(child)) {
field->parse_error = child->parse_error;
break;
}
}
}
return field;
}
int get_symbol_size(const Symbol * sym, ContextAddress * size) {
uint64_t res = 0;
DWORD tag = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
if (sym->length > 0) {
if (get_symbol_size(sym->base, size)) return -1;
*size *= sym->length;
}
else {
*size = sizeof(void *);
}
return 0;
}
if (sym->info) {
*size = sym->info->size;
return 0;
}
if (sym->module == 0) {
errno = set_errno(ERR_OTHER, "Debug info not available");
return -1;
}
if (sym->sym_class == SYM_CLASS_REFERENCE || sym->sym_class == SYM_CLASS_FUNCTION) {
SYMBOL_INFO * info = NULL;
if (get_sym_info(sym, sym->index, &info) < 0) return -1;
res = info->Size;
}
else {
Symbol type = *sym;
if (get_type_tag(&type, &tag)) return -1;
if (get_type_info(&type, TI_GET_LENGTH, &res) < 0) return -1;
}
*size = (ContextAddress)res;
return 0;
}
int get_symbol_type_class(const Symbol * sym, int * type_class) {
int res = TYPE_CLASS_UNKNOWN;
Symbol type = *sym;
DWORD tag = 0;
DWORD base = 0;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
*type_class = sym->length == 0 ? TYPE_CLASS_POINTER : TYPE_CLASS_ARRAY;
return 0;
}
if (sym->info) {
if (sym->info->real) {
*type_class = TYPE_CLASS_REAL;
}
else if (sym->info->sign) {
*type_class = TYPE_CLASS_INTEGER;
}
else {
*type_class = TYPE_CLASS_CARDINAL;
}
return 0;
}
if (get_type_tag(&type, &tag)) return -1;
switch (tag) {
case SymTagFunction:
case SymTagPublicSymbol:
res = TYPE_CLASS_FUNCTION;
break;
case SymTagEnum:
res = TYPE_CLASS_ENUMERATION;
break;
case SymTagFunctionType:
res = TYPE_CLASS_FUNCTION;
break;
case SymTagPointerType:
res = TYPE_CLASS_POINTER;
break;
case SymTagArrayType:
res = TYPE_CLASS_ARRAY;
break;
case SymTagUDT:
res = TYPE_CLASS_COMPOSITE;
break;
case SymTagBaseType:
if (get_type_info(&type, TI_GET_BASETYPE, &base) < 0) return -1;
switch (base) {
case btNoType:
break;
case btVoid:
case btChar:
case btWChar:
case btInt:
case btBool:
case btLong:
case btBit:
res = TYPE_CLASS_INTEGER;
break;
case btUInt:
case btULong:
res = TYPE_CLASS_CARDINAL;
break;
case btFloat:
res = TYPE_CLASS_REAL;
break;
case btBCD:
case btCurrency:
case btDate:
case btVariant:
case btComplex:
case btBSTR:
case btHresult:
break;
}
break;
}
*type_class = res;
return 0;
}
const char *qd_parse_turbo(qd_iterator_t *iter,
qd_parsed_turbo_list_t *annos,
uint32_t *user_entries,
uint32_t *user_bytes)
{
if (!iter || !annos || !user_entries || !user_bytes)
return "missing argument";
DEQ_INIT(*annos);
*user_entries = 0;
*user_bytes = 0;
// The iter is addressing the message-annotations map.
// Open the field describing the map's items
uint8_t tag = 0;
uint32_t size = 0;
uint32_t count = 0;
uint32_t length_of_count = 0;
uint32_t length_of_size = 0;
const char * parse_error = get_type_info(iter, &tag, &size, &count, &length_of_size, &length_of_count);
if (parse_error)
return parse_error;
if (count == 0)
return 0;
int n_allocs = 0;
// Do skeletal parse of each map element
for (uint32_t idx = 0; idx < count; idx++) {
qd_parsed_turbo_t *turbo;
if (n_allocs < QD_MA_FILTER_LEN * 2) {
turbo = new_qd_parsed_turbo_t();
n_allocs++;
} else {
// Retire an existing element.
// If there are this many in the list then this one cannot be a
// router annotation and must be a user annotation.
turbo = DEQ_HEAD(*annos);
*user_entries += 1;
*user_bytes += sizeof(turbo->tag) + turbo->size + turbo->length_of_size;
DEQ_REMOVE_HEAD(*annos);
}
if (!turbo)
return "failed to allocate qd_parsed_turbo_t";
ZERO(turbo);
// Get the buffer pointers for the map element
qd_iterator_get_view_cursor(iter, &turbo->bufptr);
// Get description of the map element
parse_error = get_type_info(iter, &turbo->tag, &turbo->size, &turbo->count,
&turbo->length_of_size, &turbo->length_of_count);
if (parse_error) {
return parse_error;
}
// Save parsed element
DEQ_INSERT_TAIL(*annos, turbo);
// Advance map iterator to next map element
qd_iterator_advance(iter, turbo->size - turbo->length_of_count);
}
// remove leading annos in the queue if their prefix is not a match and
// return them as part of the user annotations
for (int idx=0; idx < n_allocs; idx += 2) {
qd_parsed_turbo_t *turbo = DEQ_HEAD(*annos);
assert(turbo);
if (qd_iterator_prefix_ptr(&turbo->bufptr, turbo->length_of_size + 1, QD_MA_PREFIX))
break;
// leading anno is a user annotation map key
// remove the key and value from the list and accumulate them as user items
*user_bytes += sizeof(turbo->tag) + turbo->size + turbo->length_of_size;
DEQ_REMOVE_HEAD(*annos);
free_qd_parsed_turbo_t(turbo);
turbo = DEQ_HEAD(*annos);
assert(turbo);
*user_bytes += sizeof(turbo->tag) + turbo->size + turbo->length_of_size;
DEQ_REMOVE_HEAD(*annos);
free_qd_parsed_turbo_t(turbo);
*user_entries += 2;
}
return parse_error;
}
// Function: process_getdetail_e
// Example: ./psmcli getdetail -e ETH0_IPV4ADDR COM.CISCO.CCSP.ETH0.IPv4_ADDR
unsigned int process_getdetail_e(int const argCnt, char const * const argVars[], char const * const busHandle) {
//printf("Command Arguments = %s\t%s\n", argVars[1], argVars[2]);
// Check if arguments are in pairs
int cmd_index = 3;
int cmd_cnt = argCnt - 3;
unsigned int ret = 0;
unsigned int iter = 0;
unsigned int func_ret = CCSP_SUCCESS;
char *psmValue = NULL;
unsigned int psmType = ccsp_string;
char *typeStr = NULL;
char *typeStrEnv = NULL;
char const func_name[] = "process_getdetail_e";
if ((cmd_cnt % 2) != 0) {
CcspTraceWarning(("<%s>[%s]: arg count = %d is not even, returning %d CCSP_ERR_INVALID_ARGUMENTS\n",
prog_name, func_name, cmd_cnt, CCSP_ERR_INVALID_ARGUMENTS));
return CCSP_ERR_INVALID_ARGUMENTS;
}
cmd_cnt = cmd_cnt/2;
// Loop over the commands and extract the values
while(cmd_cnt--) {
ret = 0;
iter = 0;
do {
ret = PSM_Get_Record_Value2((void*)busHandle,
subsys_prefix, //PSMCLI_SUBSYSTEM_PREFIX,
argVars[cmd_index+1],
&psmType, &psmValue);
iter++;
} while (( psmValue == NULL ) && ( iter < 3 ) );
if (ret == CCSP_SUCCESS) {
if (psmValue != NULL) {
get_type_info(&psmType, &typeStr, TYPE_FORMAT_CCSP);
typeStrEnv = AnscAllocateMemory(strlen(argVars[cmd_index]) +
strlen("_TYPE") + 1);
strncpy(typeStrEnv, argVars[cmd_index], strlen(argVars[cmd_index])+1);
strcat(typeStrEnv, "_TYPE");
printf("%s=\"%s\"\n",typeStrEnv, typeStr);
printf("%s=\"%s\"\n",argVars[cmd_index], psmValue);
AnscFreeMemory(typeStrEnv);
AnscFreeMemory(typeStr);
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
typeStrEnv = typeStr = psmValue = NULL;
} else {
CcspTraceWarning(("<%s>[%s]: '%s'-> psmValue is NULL, return set to %d = CCSP_CR_ERR_INVALID_PARAM\n",
prog_name, func_name, argVars[cmd_index+1], ret));
func_ret = ret;
}
} else if (ret == CCSP_CR_ERR_INVALID_PARAM) {
CcspTraceWarning(("<%s>[%s]: invalid paramter '%s', return set to %d = CCSP_CR_ERR_INVALID_PARAM\n",
prog_name, func_name, argVars[cmd_index+1], ret));
func_ret = ret;
if(psmValue != NULL) {
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
psmValue = NULL;
}
// break; // to accommondate more cmd
} else {
// Can choose to stop further procesing - use break
// CcspTraceDebug(("<%s>[%s]: processing '%s' unsuccessful, return set to %d\n",
// prog_name, func_name, argVars[cmd_index+1], ret));
func_ret = ret;
if(psmValue != NULL) {
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
psmValue = NULL;
}
// break; // to accommondate more cmd
}
cmd_index += 2;
}
if (psmValue != NULL) ((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
// CcspTraceDebug(("<%s>[%s]: function finished returing %d\n", prog_name, func_name, func_ret));
return func_ret;
}
EAP_FUNC_EXPORT eap_status_e eap_plugin_server_message_if_c::process_message(eap_process_tlv_message_data_c * const message)
{
// Parses message data composed of Attribute-Value Pairs.
EAP_TRACE_DATA_DEBUG(
m_am_tools,
EAP_TRACE_FLAGS_NEVER,
(EAPL("eap_plugin_server_message_if_c::process_message()"),
message->get_message_data(),
message->get_message_data_length()));
EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, TRACE_FLAGS_DEFAULT, "returns: eap_plugin_server_message_if_c::process_message()");
eap_array_c<eap_tlv_header_c> parameters(m_am_tools);
eap_status_e status = message->parse_message_data(¶meters);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
(void) send_error_message(
status,
eap_tlv_message_type_function_none);
return EAP_STATUS_RETURN(m_am_tools, status);
}
if (parameters.get_object_count() == 0)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
status = eap_status_illegal_parameter;
(void) send_error_message(
status,
eap_tlv_message_type_function_none);
return EAP_STATUS_RETURN(m_am_tools, status);
}
const eap_tlv_header_c * const function_header = parameters.get_object(eap_message_payload_index_function);
if (function_header == 0
|| (function_header->get_type() != eap_tlv_message_type_error
&& function_header->get_type() != eap_tlv_message_type_function))
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
status = eap_status_illegal_parameter;
(void) send_error_message(
status,
eap_tlv_message_type_function_none);
return EAP_STATUS_RETURN(m_am_tools, status);
}
if (function_header->get_type() == eap_tlv_message_type_error)
{
status = process_message_type_error(¶meters);
}
else // function_header->get_type() == eap_tlv_message_type_function
{
eap_tlv_message_type_function_e function(eap_tlv_message_type_function_none);
status = message->get_parameter_data(function_header, &function);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
(void) send_error_message(
status,
eap_tlv_message_type_function_none);
return EAP_STATUS_RETURN(m_am_tools, status);
}
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("eap_plugin_server_message_if_c::process_message(): this = 0x%08x, message=%d=%s\n"),
this,
function,
eap_process_tlv_message_data_c::get_function_string(function)));
switch(function)
{
case eap_tlv_message_type_function_plugin_get_configuration:
status = get_configuration(¶meters);
break;
case eap_tlv_message_type_function_plugin_set_configuration:
status = set_configuration(¶meters);
break;
case eap_tlv_message_type_function_plugin_copy_configuration:
status = copy_configuration(¶meters);
break;
case eap_tlv_message_type_function_plugin_delete_configuration:
status = delete_configuration(¶meters);
break;
case eap_tlv_message_type_function_plugin_set_index:
status = set_index(¶meters);
break;
case eap_tlv_message_type_function_plugin_get_type_info:
status = get_type_info(¶meters);
break;
case eap_tlv_message_type_function_plugin_invoke_ui:
status = invoke_ui(¶meters);
break;
default:
EAP_TRACE_ERROR(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("ERROR: process_data(): unknown function %d.\n"),
function));
status = eap_status_illegal_parameter;
EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);
};
if (status != eap_status_ok
&& status != eap_status_success
&& status != eap_status_pending_request
&& status != eap_status_completed_request
&& status != eap_status_drop_packet_quietly)
{
(void) send_error_message(
status,
function);
}
}
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
std::vector<llvm::Value*> Executor::codegen(const Analyzer::Expr* expr,
const bool fetch_columns,
const CompilationOptions& co) {
if (!expr) {
return {posArg(expr)};
}
auto iter_expr = dynamic_cast<const Analyzer::IterExpr*>(expr);
if (iter_expr) {
#ifdef ENABLE_MULTIFRAG_JOIN
if (iter_expr->get_rte_idx() > 0) {
const auto offset = cgen_state_->frag_offsets_[iter_expr->get_rte_idx()];
if (offset) {
return {cgen_state_->ir_builder_.CreateAdd(posArg(iter_expr), offset)};
} else {
return {posArg(iter_expr)};
}
}
#endif
return {posArg(iter_expr)};
}
auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
if (bin_oper) {
return {codegen(bin_oper, co)};
}
auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
if (u_oper) {
return {codegen(u_oper, co)};
}
auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr);
if (col_var) {
return codegen(col_var, fetch_columns, co);
}
auto constant = dynamic_cast<const Analyzer::Constant*>(expr);
if (constant) {
if (constant->get_is_null()) {
const auto& ti = constant->get_type_info();
return {ti.is_fp() ? static_cast<llvm::Value*>(inlineFpNull(ti)) : static_cast<llvm::Value*>(inlineIntNull(ti))};
}
// The dictionary encoding case should be handled by the parent expression
// (cast, for now), here is too late to know the dictionary id
CHECK_NE(kENCODING_DICT, constant->get_type_info().get_compression());
return {codegen(constant, constant->get_type_info().get_compression(), 0, co)};
}
auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr);
if (case_expr) {
return {codegen(case_expr, co)};
}
auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr);
if (extract_expr) {
return {codegen(extract_expr, co)};
}
auto dateadd_expr = dynamic_cast<const Analyzer::DateaddExpr*>(expr);
if (dateadd_expr) {
return {codegen(dateadd_expr, co)};
}
auto datediff_expr = dynamic_cast<const Analyzer::DatediffExpr*>(expr);
if (datediff_expr) {
return {codegen(datediff_expr, co)};
}
auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr);
if (datetrunc_expr) {
return {codegen(datetrunc_expr, co)};
}
auto charlength_expr = dynamic_cast<const Analyzer::CharLengthExpr*>(expr);
if (charlength_expr) {
return {codegen(charlength_expr, co)};
}
auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr);
if (like_expr) {
return {codegen(like_expr, co)};
}
auto regexp_expr = dynamic_cast<const Analyzer::RegexpExpr*>(expr);
if (regexp_expr) {
return {codegen(regexp_expr, co)};
}
auto likelihood_expr = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
if (likelihood_expr) {
return {codegen(likelihood_expr->get_arg(), fetch_columns, co)};
}
auto in_expr = dynamic_cast<const Analyzer::InValues*>(expr);
if (in_expr) {
return {codegen(in_expr, co)};
}
auto in_integer_set_expr = dynamic_cast<const Analyzer::InIntegerSet*>(expr);
if (in_integer_set_expr) {
return {codegen(in_integer_set_expr, co)};
}
auto function_oper_with_custom_type_handling_expr =
dynamic_cast<const Analyzer::FunctionOperWithCustomTypeHandling*>(expr);
if (function_oper_with_custom_type_handling_expr) {
return {codegenFunctionOperWithCustomTypeHandling(function_oper_with_custom_type_handling_expr, co)};
}
auto function_oper_expr = dynamic_cast<const Analyzer::FunctionOper*>(expr);
if (function_oper_expr) {
return {codegenFunctionOper(function_oper_expr, co)};
}
abort();
}
Executor::GroupColLLVMValue Executor::groupByColumnCodegen(Analyzer::Expr* group_by_col,
const size_t col_width,
const CompilationOptions& co,
const bool translate_null_val,
const int64_t translated_null_val,
GroupByAndAggregate::DiamondCodegen& diamond_codegen,
std::stack<llvm::BasicBlock*>& array_loops,
const bool thread_mem_shared) {
#ifdef ENABLE_KEY_COMPACTION
CHECK_GE(col_width, sizeof(int32_t));
#else
CHECK_EQ(col_width, sizeof(int64_t));
#endif
auto group_key = codegen(group_by_col, true, co).front();
auto key_to_cache = group_key;
if (dynamic_cast<Analyzer::UOper*>(group_by_col) &&
static_cast<Analyzer::UOper*>(group_by_col)->get_optype() == kUNNEST) {
auto preheader = cgen_state_->ir_builder_.GetInsertBlock();
auto array_loop_head = llvm::BasicBlock::Create(
cgen_state_->context_, "array_loop_head", cgen_state_->row_func_, preheader->getNextNode());
diamond_codegen.setFalseTarget(array_loop_head);
const auto ret_ty = get_int_type(32, cgen_state_->context_);
auto array_idx_ptr = cgen_state_->ir_builder_.CreateAlloca(ret_ty);
CHECK(array_idx_ptr);
cgen_state_->ir_builder_.CreateStore(ll_int(int32_t(0)), array_idx_ptr);
const auto arr_expr = static_cast<Analyzer::UOper*>(group_by_col)->get_operand();
const auto& array_ti = arr_expr->get_type_info();
CHECK(array_ti.is_array());
const auto& elem_ti = array_ti.get_elem_type();
auto array_len = cgen_state_->emitExternalCall(
"array_size", ret_ty, {group_key, posArg(arr_expr), ll_int(log2_bytes(elem_ti.get_logical_size()))});
cgen_state_->ir_builder_.CreateBr(array_loop_head);
cgen_state_->ir_builder_.SetInsertPoint(array_loop_head);
CHECK(array_len);
auto array_idx = cgen_state_->ir_builder_.CreateLoad(array_idx_ptr);
auto bound_check = cgen_state_->ir_builder_.CreateICmp(llvm::ICmpInst::ICMP_SLT, array_idx, array_len);
auto array_loop_body = llvm::BasicBlock::Create(cgen_state_->context_, "array_loop_body", cgen_state_->row_func_);
cgen_state_->ir_builder_.CreateCondBr(
bound_check, array_loop_body, array_loops.empty() ? diamond_codegen.orig_cond_false_ : array_loops.top());
cgen_state_->ir_builder_.SetInsertPoint(array_loop_body);
cgen_state_->ir_builder_.CreateStore(cgen_state_->ir_builder_.CreateAdd(array_idx, ll_int(int32_t(1))),
array_idx_ptr);
const auto array_at_fname = "array_at_" + numeric_type_name(elem_ti);
const auto ar_ret_ty = elem_ti.is_fp()
? (elem_ti.get_type() == kDOUBLE ? llvm::Type::getDoubleTy(cgen_state_->context_)
: llvm::Type::getFloatTy(cgen_state_->context_))
: get_int_type(elem_ti.get_logical_size() * 8, cgen_state_->context_);
group_key = cgen_state_->emitExternalCall(array_at_fname, ar_ret_ty, {group_key, posArg(arr_expr), array_idx});
if (need_patch_unnest_double(elem_ti, isArchMaxwell(co.device_type_), thread_mem_shared)) {
key_to_cache = spillDoubleElement(group_key, ar_ret_ty);
} else {
key_to_cache = group_key;
}
CHECK(array_loop_head);
array_loops.push(array_loop_head);
}
cgen_state_->group_by_expr_cache_.push_back(key_to_cache);
llvm::Value* orig_group_key{nullptr};
if (translate_null_val) {
const std::string translator_func_name(col_width == sizeof(int32_t) ? "translate_null_key_i32_"
: "translate_null_key_");
const auto& ti = group_by_col->get_type_info();
const auto key_type = get_int_type(ti.get_logical_size() * 8, cgen_state_->context_);
orig_group_key = group_key;
group_key =
cgen_state_->emitCall(translator_func_name + numeric_type_name(ti),
{group_key,
static_cast<llvm::Value*>(llvm::ConstantInt::get(key_type, inline_int_null_val(ti))),
static_cast<llvm::Value*>(llvm::ConstantInt::get(key_type, translated_null_val))});
}
group_key = cgen_state_->ir_builder_.CreateBitCast(castToTypeIn(group_key, col_width * 8),
get_int_type(col_width * 8, cgen_state_->context_));
if (orig_group_key) {
orig_group_key = cgen_state_->ir_builder_.CreateBitCast(castToTypeIn(orig_group_key, col_width * 8),
get_int_type(col_width * 8, cgen_state_->context_));
}
return {group_key, orig_group_key};
}
// Function: process_getdetail
// Example: ./psmcli getdetail COM.CISCO.CCSP.ETH0.IPv4_ADDR
unsigned int process_getdetail(int const argCnt, char const * const argVars[], char const * const busHandle) {
int cmd_index = 2;
int cmd_cnt = argCnt - 2;
unsigned int ret = 0;
unsigned int iter = 0;
unsigned int func_ret = CCSP_SUCCESS;
char *psmValue = NULL;
unsigned int psmType = ccsp_string;
char *typeStr = NULL;
char const func_name[] = "process_getdetail";
// Loop over the commands and extract the values
while(cmd_cnt--) {
ret = 0;
iter = 0;
do {
ret = PSM_Get_Record_Value2((void*)busHandle,
subsys_prefix, // PSMCLI_SUBSYSTEM_PREFIX,
argVars[cmd_index],
&psmType, &psmValue);
iter++;
} while (( psmValue == NULL ) && ( iter < 3 ) );
if (ret == CCSP_SUCCESS) {
if (psmValue != NULL) {
get_type_info(&psmType, &typeStr, TYPE_FORMAT_CCSP);
if(typeStr != NULL) {
printf("%s\n%s\n", typeStr, psmValue);
AnscFreeMemory(typeStr);
}
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
typeStr = psmValue = NULL;
} else {
CcspTraceWarning(("<%s>[%s]: '%s'-> psmValue is NULL, return set to %d = CCSP_CR_ERR_INVALID_PARAM\n",
prog_name, func_name, argVars[cmd_index], ret));
func_ret = ret;
}
} else if (ret == CCSP_CR_ERR_INVALID_PARAM) {
CcspTraceWarning(("<%s>[%s]: invalid paramter '%s', return set to %d = CCSP_CR_ERR_INVALID_PARAM\n",
prog_name, func_name, argVars[cmd_index], ret));
func_ret = ret;
if(psmValue != NULL) {
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
psmValue = NULL;
}
// break; // to accommondate cmd_cnt > 1
} else {
// Can choose to stop further processing - use break
CcspTraceWarning(("<%s>[%s]: processing '%s' unsuccessful, returning %d\n",
prog_name, func_name, argVars[cmd_index], ret));
func_ret = ret;
if(psmValue != NULL) {
((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
psmValue = NULL;
}
// break; // to accommondate cmd_cnt > 1
}
cmd_index++;
}
if(psmValue != NULL) ((CCSP_MESSAGE_BUS_INFO*)busHandle)->freefunc(psmValue);
// CcspTraceDebug(("<%s>[%s]: function finished returing %d\n", prog_name, func_name, func_ret));
return func_ret;
}
int get_symbol_name(const Symbol * sym, char ** name) {
WCHAR * ptr = NULL;
assert(sym->magic == SYMBOL_MAGIC);
if (sym->base) {
*name = NULL;
return 0;
}
if (sym->info) {
*name = sym->info->name;
return 0;
}
*name = NULL;
if (get_type_info(sym, TI_GET_SYMNAME, &ptr) < 0) ptr = NULL;
if (ptr != NULL && wcscmp(ptr, L"<unnamed-tag>") == 0) ptr = NULL;
if (ptr != NULL) {
int len = 0;
int err = 0;
if (tmp_buf == NULL) {
tmp_buf_size = 256;
tmp_buf = (char *)loc_alloc(tmp_buf_size);
}
for (;;) {
len = WideCharToMultiByte(CP_UTF8, 0, ptr, -1, tmp_buf, tmp_buf_size - 1, NULL, NULL);
if (len != 0) break;
err = GetLastError();
if (err != ERROR_INSUFFICIENT_BUFFER) {
set_win32_errno(err);
return -1;
}
tmp_buf_size *= 2;
tmp_buf = (char *)loc_realloc(tmp_buf, tmp_buf_size);
}
HeapFree(GetProcessHeap(), 0, ptr);
tmp_buf[len] = 0;
*name = tmp_buf;
}
else {
DWORD tag = 0;
Symbol type = *sym;
if (get_type_tag(&type, &tag)) return -1;
if (tag == SymTagBaseType) {
ContextAddress size = 0;
int type_class = 0;
unsigned char sign = 0;
unsigned char real = 0;
const TypeInfo * p = basic_type_info;
if (get_symbol_size(&type, &size)) return -1;
if (get_symbol_type_class(&type, &type_class)) return -1;
if (type_class == TYPE_CLASS_INTEGER) sign = 1;
else if (type_class == TYPE_CLASS_REAL) real = sign = 1;
while (p->name != NULL) {
if (p->size == size && p->sign == sign && p->real == real) {
*name = p->name;
break;
}
p++;
}
}
}
return 0;
}
