Beispiel #1
1
void
arch_store16(cpu_t *cpu, Value *val, Value *addr, BasicBlock *bb) {
	Value *shift = arch_get_shift16(cpu, addr, bb);
	addr = AND(addr, CONST(~3ULL));
	Value *mask = XOR(SHL(CONST(65535), shift),CONST(-1ULL));
	Value *old = AND(arch_load32_aligned(cpu, addr, bb), mask);
	val = OR(old, SHL(AND(val, CONST(65535)), shift));
	arch_store32_aligned(cpu, val, addr, bb);
}
Beispiel #2
0
// Init class pointers and fix array layout
void vm_init_const_table_elems(void) {
	uint8_t * ptr = const_table_g;
	class_t * str_cls = vm_find_class("String");
	class_t * arr_cls = vm_find_class("Array");
	constant_array_t * c_arr;
	int i;
	kek_obj_t ** elems;

	while (ptr != const_table_g + const_table_cnt_g) {
		kek_obj_t * obj = (kek_obj_t*) ptr;
		switch (obj->h.t) {
		case KEK_NIL:
			ptr += sizeof(kek_nil_t);
			break;
		case KEK_INT:
			ptr += sizeof(kek_int_t);
			break;
		case KEK_STR:
			obj->h.cls = str_cls;
			ptr += sizeof(kek_string_t) + obj->k_str.length;
			break;
		case KEK_SYM:
			if (obj->h.cls != NULL) {
				// Parent class name index stored in cls pointer
				assert(IS_SYM((kek_obj_t*) CONST((ptruint_t)obj->h.cls)));
				obj->h.cls = vm_find_class(CONST((ptruint_t)obj->h.cls)->k_sym.symbol);
			}
			else {
				obj->h.cls = vm_find_class(obj->k_sym.symbol);
			}
			ptr += sizeof(kek_symbol_t) + obj->k_sym.length;
			break;
		case KEK_ARR:
			obj->h.cls = arr_cls;

			c_arr = (constant_array_t*) obj;
			elems = alloc_const_arr_elems(obj->k_arr.length);
			//obj->k_arr.alloc_size = obj->k_arr.length;

			for (i = 0; i < c_arr->length; ++i) {
				elems[i] = CONST(c_arr->elems[i]);
			}
			obj->k_arr.elems = elems;
			arr_set_alloc_size(&obj->k_arr, obj->k_arr.length);
			assert(obj->k_arr.alloc_size > 0);
			add_carray_to_gc_rootset(&obj->k_arr);

			ptr += sizeof(constant_array_t)
					+ (obj->k_arr.length - 1) * sizeof(uint32_t);
			break;
		case KEK_EXINFO:
			ptr += sizeof(kek_exinfo_t)
					+ (obj->k_exi.length - 1) * sizeof(try_range_t);
			break;
		default:
			;
		}
	}
}
Beispiel #3
0
static Value *
arch_get_shift16(cpu_t *cpu, Value *addr, BasicBlock *bb)
{
	Value *shift = AND(LSHR(addr,CONST(1)),CONST(1));
	if (!IS_LITTLE_ENDIAN(cpu))
		shift = XOR(shift, CONST(1));
	return SHL(shift, CONST(4));
}
      std::shared_ptr<Expr> buildTpchQ6FilterExpression() {
        shared_ptr<Expr> expression(AND(GE(FIELD("l_shipdate"), CONST("1994-01-01")),
                                          LT(FIELD("l_shipdate"), CONST("1995-01-01")),
                                          GE(FIELD("l_discount"), CONST("0.05", DOUBLE)),
                                          LE(FIELD("l_discount"), CONST("0.07", DOUBLE)),
                                          LT(FIELD("l_quantity"), CONST("24", DOUBLE))
                                         ));

        return expression;
      }
Beispiel #5
0
void setupNumberGenComboBox(QScriptEngine *engine)
{
  QScriptValue glob = engine->newFunction(constructNumberGenComboBox);

  qScriptRegisterMetaType(engine, NumberGenComboBoxToScriptValue, NumberGenComboBoxFromScriptValue);

  glob.setProperty("Manual",    CONST(NumberGenComboBox::Manual),    CONSTFLAGS);
  glob.setProperty("Automatic", CONST(NumberGenComboBox::Automatic), CONSTFLAGS);
  glob.setProperty("Override",  CONST(NumberGenComboBox::Override),  CONSTFLAGS);
  glob.setProperty("Shared",    CONST(NumberGenComboBox::Shared),    CONSTFLAGS);

  engine->globalObject().setProperty("NumberGenComboBox", glob, CONSTFLAGS);
}
Beispiel #6
0
static void check_store(LLVMValueRef rvalue, LLVMValueRef lvalue)
{
	if (LLVMIsAGlobalValue(lvalue))
		rvalue = LLVMBuildShl(builder, rvalue, CONST(WORDPOW), "");

	LLVMBuildStore(builder, rvalue, lvalue);
}
Beispiel #7
0
LLVMValueRef gen_name(struct node *ast)
{
	LLVMValueRef func, ptr, val;
	LLVMTypeRef type;

	ptr = lvalue(ast);
	type = LLVMTypeOf(ptr);

	if (LLVMGetTypeKind(type) == LLVMLabelTypeKind) {
		func = LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder));
		return LLVMBuildPtrToInt(builder,
				LLVMBlockAddress(func, (LLVMBasicBlockRef)ptr),
				TYPE_INT,
				"");
	}

	type = LLVMGetElementType(LLVMTypeOf(ptr));

	switch (LLVMGetTypeKind(type)) {
	case LLVMIntegerTypeKind:
		val = LLVMBuildLoad(builder, ptr, ast->val);

		if (LLVMIsAGlobalValue(ptr))
			val = LLVMBuildLShr(builder, val, CONST(WORDPOW), "");

		return val;

	default:
		generror("unexpected type '%s'", LLVMPrintTypeToString(type));
		return NULL;
	}
}
Beispiel #8
0
LLVMValueRef gen_if(struct node *ast)
{
	LLVMValueRef condition, func;
	LLVMBasicBlockRef then_block, else_block, end;

	condition = codegen(ast->one);
	condition = LLVMBuildICmp(builder, LLVMIntNE, condition, CONST(0), "");
	func = LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder));

	then_block = LLVMAppendBasicBlock(func, "");
	else_block = LLVMAppendBasicBlock(func, "");
	end = LLVMAppendBasicBlock(func, "");
	LLVMBuildCondBr(builder, condition, then_block, else_block);

	LLVMPositionBuilderAtEnd(builder, then_block);
	codegen(ast->two);
	LLVMBuildBr(builder, end);

	LLVMPositionBuilderAtEnd(builder, else_block);
	if (ast->three)
		codegen(ast->three);
	LLVMBuildBr(builder, end);

	LLVMPositionBuilderAtEnd(builder, end);

	return NULL;
}
Beispiel #9
0
static SCM
expand_and (SCM expr, SCM env)
{
  const SCM cdr_expr = CDR (expr);

  if (scm_is_null (cdr_expr))
    return CONST (SCM_BOOL_F, SCM_BOOL_T);

  ASSERT_SYNTAX (scm_is_pair (cdr_expr), s_bad_expression, expr);

  if (scm_is_null (CDR (cdr_expr)))
    return expand (CAR (cdr_expr), env);
  else
    return CONDITIONAL (scm_source_properties (expr),
                        expand (CAR (cdr_expr), env),
                        expand_and (cdr_expr, env),
                        CONST (SCM_BOOL_F, SCM_BOOL_F));
}
Beispiel #10
0
static LLVMValueRef lvalue_to_rvalue(LLVMValueRef lvalue)
{
	/*
	* TODO: Make sure all addresses are word-aligned
	*       (autos, vectors, strings, etc.)
	*/
	lvalue = LLVMBuildPtrToInt(builder, lvalue, TYPE_INT, "");

	return LLVMBuildLShr(builder, lvalue, CONST(WORDPOW), "");
}
Beispiel #11
0
static LLVMValueRef make_char(const char *str)
{
	LLVMValueRef charval;

	/* Skip leading ' */
	str += 1;
	charval = CONST(pack_char(&str));

	return charval;
}
Beispiel #12
0
static SCM
expand_quote (SCM expr, SCM env SCM_UNUSED)
{
  SCM quotee;

  const SCM cdr_expr = CDR (expr);
  ASSERT_SYNTAX (scm_ilength (cdr_expr) >= 0, s_bad_expression, expr);
  ASSERT_SYNTAX (scm_ilength (cdr_expr) == 1, s_expression, expr);
  quotee = CAR (cdr_expr);
  return CONST (scm_source_properties (expr), quotee);
}
Beispiel #13
0
LLVMValueRef gen_simpledef(struct node *ast)
{
	LLVMValueRef global, init;

	global = find_or_add_global(ast->one->val);
	init = LLVMConstShl(codegen(ast->two), CONST(WORDPOW));

	LLVMSetInitializer(global, init);

	return NULL;
}
Beispiel #14
0
static void init_const_sym_pointers(void) {
	uint32_t i, j;

	for (i = 0; i < classes_cnt_g; ++i) {
		for (j = 0; j < classes_g[i].syms_static_cnt; ++j) {
			if (classes_g[i].syms_static[j].const_flag) {
				classes_g[i].syms_static[j].value = CONST(
						classes_g[i].syms_static[j].const_ptr);
			}
		}
	}
}
Beispiel #15
0
LLVMValueRef gen_not(struct node *ast)
{
	LLVMValueRef truth;

	truth = LLVMBuildICmp(builder,
			LLVMIntEQ,
			codegen(ast->one),
			CONST(0),
			"");

	return LLVMBuildZExt(builder, truth, TYPE_INT, "");
}
Beispiel #16
0
static LLVMValueRef make_str(const char *str)
{
	LLVMValueRef global, strval, chars[MAX_STRSIZE];
	const char *p;
	int size = 0;

	/* Skip leading " */
	p = str + 1;
	while (p && size < MAX_STRSIZE - 1)
		chars[size++] = CONST(pack_char(&p));

	chars[size++] = CONST(EOT);

	global = LLVMAddGlobal(module, TYPE_ARRAY(size), ".gstr");
	LLVMSetLinkage(global, LLVMPrivateLinkage);

	strval = LLVMConstArray(TYPE_INT, chars, size);
	LLVMSetInitializer(global, strval);

	return lvalue_to_rvalue(global);
}
Beispiel #17
0
LLVMValueRef gen_predec(struct node *ast)
{
	LLVMValueRef result;

	result = LLVMBuildSub(builder,
			codegen(ast->one),
			CONST(1),
			"");

	check_store(result, lvalue(ast->one));

	return result;
}
Beispiel #18
0
LLVMValueRef gen_postdec(struct node *ast)
{
	LLVMValueRef orig, result;

	orig = codegen(ast->one);

	result = LLVMBuildSub(builder,
			orig,
			CONST(1),
			"");

	check_store(result, lvalue(ast->one));

	return orig;
}
Beispiel #19
0
LLVMValueRef gen_cond(struct node *ast)
{
	LLVMValueRef truth;

	truth = LLVMBuildICmp(builder,
			LLVMIntNE,
			codegen(ast->one),
			CONST(0),
			"");

	return LLVMBuildSelect(builder,
			truth,
			codegen(ast->two),
			codegen(ast->three),
			"");
}
Beispiel #20
0
static SCM
expand (SCM exp, SCM env)
{
  if (scm_is_pair (exp))
    {
      SCM car;
      scm_t_macro_primitive trans = NULL;
      SCM macro = SCM_BOOL_F;
      
      car = CAR (exp);
      if (scm_is_symbol (car))
        macro = expand_env_ref_macro (env, car);
      
      if (scm_is_true (macro))
        trans = scm_i_macro_primitive (macro);

      if (trans)
        return trans (exp, env);
      else
        {
          SCM arg_exps = SCM_EOL;
          SCM args = SCM_EOL;
          SCM proc = CAR (exp);
          
          for (arg_exps = CDR (exp); scm_is_pair (arg_exps);
               arg_exps = CDR (arg_exps))
            args = scm_cons (expand (CAR (arg_exps), env), args);
          if (scm_is_null (arg_exps))
            return CALL (scm_source_properties (exp),
                         expand (proc, env),
                         scm_reverse_x (args, SCM_UNDEFINED));
          else
            syntax_error ("expected a proper list", exp, SCM_UNDEFINED);
        }
    }
  else if (scm_is_symbol (exp))
    {
      SCM gensym = expand_env_lexical_gensym (env, exp);
      if (scm_is_true (gensym))
        return LEXICAL_REF (SCM_BOOL_F, exp, gensym);
      else
        return TOPLEVEL_REF (SCM_BOOL_F, exp);
    }
  else
    return CONST (SCM_BOOL_F, exp);
}
Beispiel #21
0
LLVMValueRef gen_ivals(struct node *ast)
{
	LLVMValueRef *ival_list;
	int size, i;

	size = count_chain(ast);
	ival_list = calloc(sizeof(LLVMValueRef), size);

	if (size > 0 && ival_list == NULL)
		generror("out of memory");

	for (i = 0; i < size; i++, ast = ast->two)
		ival_list[i] = codegen(ast->one);

	/* TODO: Figure out how to initialize int with vector without error */
	/*return LLVMConstArray(TYPE_INT, ival_list, size);*/
	return size ? ival_list[0] : CONST(0);
}
Beispiel #22
0
LLVMValueRef gen_vecdef(struct node *ast)
{
	LLVMValueRef global, array, init, *ival_list;
	struct node *n;
	int size, initsize, i;

	initsize = count_chain(ast->three);

	if (ast->two)
		size = LLVMConstIntGetZExtValue(codegen(ast->two));
	else
		size = 0;

	if (initsize > size)
		size = initsize;

	ival_list = calloc(sizeof(LLVMValueRef), size);

	if (size > 0 && ival_list == NULL)
		generror("out of memory");

	for (i = 0, n = ast->three; i < initsize; i++, n = n->two)
		/* TODO: handle NAMES (convert global pointer to int) */
		ival_list[initsize - i - 1] = codegen(n->one);

	for (i = initsize; i < size; i++)
		ival_list[i] = CONST(0);

	global = find_or_add_global(ast->one->val);
	array = LLVMAddGlobal(module, TYPE_ARRAY(size), ".gvec");
	LLVMSetLinkage(array, LLVMPrivateLinkage);

	if (initsize)
		init = LLVMConstArray(TYPE_INT, ival_list, size);
	else
		init = LLVMConstNull(TYPE_ARRAY(size));

	LLVMSetInitializer(array, init);
	LLVMSetInitializer(global, LLVMBuildPtrToInt(builder, array, TYPE_INT, ""));

	return NULL;
}
Beispiel #23
0
bool kexe_load(const char *filename) {
	FILE *f;

	f = fopen(filename, "rb");
	if (f == NULL) {
		vm_error("Filename \"%s\" does not exists.\n", filename);
		return (false);
	}

	if (!kexe_load_magic(f)) {
		vm_error("kexe_load_magic has failed.\n");
		goto error;
	}

	if (!kexe_load_classes(f)) {
		vm_error("kexe_load_classes has failed.\n");
		goto error;
	}

	if (!kexe_load_const_table(f)) {
		vm_error("kexe_load_const_table has failed.\n");
		goto error;
	}

	if (!kexe_load_bc_arr(f)) {
		vm_error("kexe_load_bc_arr has failed.\n");
		goto error;
	}

	init_const_sym_pointers();

	assert(IS_NIL(CONST(0)));

	fclose(f);
	return (true);

	error: /* cleanup */
	/* TODO: cleanup */
	fclose(f);
	return (false);
}
Beispiel #24
0
static SCM
expand_or (SCM expr, SCM env SCM_UNUSED)
{
  SCM tail = CDR (expr);
  const long length = scm_ilength (tail);

  ASSERT_SYNTAX (length >= 0, s_bad_expression, expr);

  if (scm_is_null (CDR (expr)))
    return CONST (SCM_BOOL_F, SCM_BOOL_F);
  else
    {
      SCM tmp = scm_gensym (SCM_UNDEFINED);
      return LET (SCM_BOOL_F,
                  scm_list_1 (tmp), scm_list_1 (tmp),
                  scm_list_1 (expand (CADR (expr), env)),
                  CONDITIONAL (SCM_BOOL_F,
                               LEXICAL_REF (SCM_BOOL_F, tmp, tmp),
                               LEXICAL_REF (SCM_BOOL_F, tmp, tmp),
                               expand_or (CDR (expr),
                                          scm_acons (tmp, tmp, env))));
    }
}
Beispiel #25
0

#define OS_START_SEC_CODE
#include "tpl_memmap.h"

/**
 * Function used to call the application error hook
 *
 * @param error error code which raised the hook call
 *
 * Do not call it directly, use #PROCESS_ERROR macro
 *
 * @see #PROCESS_ERROR
 */
FUNC(void, OS_CODE) tpl_call_error_hook(
    CONST(tpl_status, AUTOMATIC) error)
{

/**
 * This flag is used to avoid error hook call recursion
 */
    STATIC VAR(tpl_bool, AUTOMATIC) in_error_hook = FALSE;

    if (!in_error_hook)
    {
#if WITH_MEMORY_PROTECTION == YES
        tpl_kern.running_trusted = 1;
#endif /* WITH_MEMORY_PROTECTION == YES */
        in_error_hook = TRUE;
        ErrorHook(error);
#if WITH_MEMORY_PROTECTION == YES
Beispiel #26
0
 * @section infos File informations
 *
 * $Date$
 * $Rev$
 * $Author$
 * $URL$
 */

#include "tpl_os_os.h"
#include "tpl_os_kernel.h"
#include "tpl_machine_interface.h"

#define API_START_SEC_CODE
#include "tpl_memmap.h"

extern FUNC(void, OS_CODE) tpl_start_os(CONST(AppModeType, AUTOMATIC) mode);

/**
 * Starts Trampoline
 *
 * @param mode chosen application mode
 *
 * see paragraph 13.7.2.2 page 66 of OSEK/VDX 2.2.2 spec
 */
FUNC(void, OS_CODE) StartOS(
  CONST(AppModeType, AUTOMATIC) mode)
{
  GET_CURRENT_CORE_ID(core_id)

  if (tpl_current_os_state(CORE_ID_OR_NOTHING(core_id)) == OS_INIT)
  {
Beispiel #27
0
#include "tpl_os_definitions.h"

#if WITH_SYSTEM_CALL == NO

#include "tpl_os_event.h"
#include "tpl_os_event_kernel.h"

#define API_START_SEC_CODE
#include "tpl_memmap.h"

/*
 * SetEvent
 */
FUNC(StatusType, OS_CODE) SetEvent(
    CONST(TaskType, AUTOMATIC)      task_id,
    CONST(EventMaskType, AUTOMATIC) event)
{
    StatusType result = tpl_set_event_service(task_id, event);
    return result & OSEK_STATUS_MASK;
}


/*
 * ClearEvent
 * see paragraph 13.5.3.2, page 61 of OSEK spec 2.2.2
 */
FUNC(StatusType, OS_CODE) ClearEvent(
    CONST(EventMaskType, AUTOMATIC) event)
{
    return tpl_clear_event_service(event);
Beispiel #28
0
#include "tpl_memmap.h"

/*
 * GetActiveApplicationMode return the active application mode
 */
FUNC(AppModeType, OS_CODE) GetActiveApplicationMode(void)
{
  return tpl_get_active_application_mode_service();
}

/*
 * StartOS can be called by the app to start the OS in
 * an appropriate mode.
 */
FUNC(void, OS_CODE) tpl_start_os(
    CONST(AppModeType, AUTOMATIC) mode)
{
  tpl_start_os_service(mode);
}

/*
 * ShutdownOS can be called by the app to shutdown it
 */
FUNC(void, OS_CODE) ShutdownOS(
    CONST(StatusType, AUTOMATIC) error  /*@unused@*/
)
{
  tpl_shutdown_os_service(error);
}

#define OS_STOP_SEC_CODE
#define OS_STOP_SEC_VAR_UNSPECIFIED
#include "tpl_memmap.h"

#define OS_START_SEC_CODE
#include "tpl_memmap.h"

/**
 * @internal
 *
 * tpl_release_all_resources releases all the resources got by a process
 * Since this function is called when the proccess is killed, the priority
 * of the process is not changed by this function.
 * No rescheduling is done.
 */
FUNC(void, OS_CODE) tpl_release_all_resources(
  CONST(tpl_proc_id, AUTOMATIC) proc_id)
{
  /*  Get the resource pointer of the process */
  P2VAR(tpl_resource, AUTOMATIC, OS_APPL_DATA) res =
  tpl_dyn_proc_table[proc_id]->resources;
#if WITH_TRACE == YES
  VAR(tpl_resource_id, AUTOMATIC) res_id;
#endif /* WITH_TRACE */

  if (res != NULL)
  {
    tpl_dyn_proc_table[proc_id]->resources = NULL;

    do
    {
      CONSTP2VAR(tpl_resource, AUTOMATIC, OS_APPL_DATA) next_res =
Beispiel #30
0
Value *
arch_load16_aligned(cpu_t *cpu, Value *addr, BasicBlock *bb) {
	Value *shift = arch_get_shift16(cpu, addr, bb);
	Value *val = arch_load32_aligned(cpu, AND(addr, CONST(~3ULL)), bb);
	return TRUNC16(LSHR(val, shift));
}