Thread: I can't spot my mistake...

I'll start with the output

Code:

make rebuild
MAKECMDGOALS=rebuild
make -f main.mak rebuild
make[1]: Entering directory '~/alu'
PRJ_SRC_FILES = 'test.c alu_bit.c alu_main.c alu_math.c alu_mem.c alu_vec.c'
rm -f *.AppImage *.exe *.so *.dll *.o *.obj
cc -fPIC -shared -Wall -Wextra -I cloned/fbstdc/include  -o test.o -c test.c
make[1]: Leaving directory '~/alu'
fatal: not in a git directory
In file included from test.c:1:
alu.h:12:10: fatal error: allstdint.h: No such file or directory
   12 | #include <allstdint.h>
      |          ^~~~~~~~~~~~~
compilation terminated.
make[1]: *** [main.mak:98: test.o] Error 1
make: *** [1st.mak:6: rebuild] Error 2
Compilation failed.

I've checked and the files were certainly downloaded and saved to the right place, I'm guessing I'm using the -I flag wrong maybe? If you need more just tell me what you're looking for and I'll post it

Never mind, just spotted my mistake, I had renamed the files but forgot to change it in code

I add

Code:

.LIBPATTERNS:=$(DST_LIB_PFX)%.$(DST_LIB_SFX) $(DST_LIB_PFX)%.a

to the dst_sys.mak header so that should reduce linkage errors

Made another mistake that I can't identify, this seemed an appropriate thread to tack it onto instead of creating another thread.
This:

Code:

$(info $(call rebase,$(FBSTDC_DIR)))
$(shell $(call rebase,$(FBSTDC_DIR)))

Lead to this:

Code:

cd 'cloned/fbstdc' && git config pull.rebase true && git pull
main.mak:42: *** missing separator.  Stop.

Any ideas what I did wrong there?

Managed to fix the issue with register acquisition but now encountering a stack smashing fault, I don't know how to look for the cause of that so I would appreciate suggestions, the only info I currently have from debugging is the function it occurs in and the last value printed

Code:

char *pos_int[] = {
	"123",
	"+145",
	"0xA",
	"0b1",
NULL };

char *neg_int[] = {
	"-123",
	"-0xA",
	"-0b1", // This is the last value printed
NULL };

char *pos_fpn[] = {
	"0",
	"1",
	"1.0",
	"0.1",
	"1.1",
	"1e+10",
	"1.0e+10",
	"0.1e+10",
	"1.1e+10",
	"1e-10",
	"1.0e-10",
	"0.1e-10",
	"1.1e-10",
	"0xA",
	"0xA.0",
	"0x0.A",
	"0xA.A",
	"0xAp+10",
	"0xA.0p+10",
	"0x0.Ap+10",
	"0xA.Ap+10",
	"0xAp-10",
	"0xA.0p-10",
	"0x0.Ap-10",
	"0xA.Ap-10",
	"0b1",
	"0b1.0",
	"0b0.1",
	"0b1.1",
	"0b1e+10",
	"0b1.0e+10",
	"0b0.1e+10",
	"0b1.1e+10",
	"0b1e-10",
	"0b1.0e-10",
	"0b0.1e-10",
	"0b1.1e-10",
NULL };

char *neg_fpn[] = {
	"-0.0",
	"-1",
	"-1.0",
	"-0.1",
	"-1.1",
	"-1e+10",
	"-1.0e+10",
	"-0.1e+10",
	"-1.1e+10",
	"-1e-10",
	"-1.0e-10",
	"-0.1e-10",
	"-1.1e-10",
	"-0xA",
	"-0xA.0",
	"-0x0.A",
	"-0xA.A",
	"-0xAp+10",
	"-0xA.0p+10",
	"-0x0.Ap+10",
	"-0xA.Ap+10",
	"-0xAp-10",
	"-0xA.0p-10",
	"-0x0.Ap-10",
	"-0xA.Ap-10",
	"-0b1",
	"-0b1.0",
	"-0b0.1",
	"-0b1.1",
	"-0b1e+10",
	"-0b1.0e+10",
	"-0b0.1e+10",
	"-0b1.1e+10",
	"-0b1e-10",
	"-0b1.0e-10",
	"-0b0.1e-10",
	"-0b1.1e-10",
NULL };

int print_value( alu_t *alu, bool print_anyways )
{
	int ret = 0, i;
	alu_src_t _src = {NULL};
	alu_dst_t _dst = {NULL};
	alu_base_t base = {0};
	alu_lit_t lit = {0};
	alu_block_t __src = {0}, __dst = {0};
	char *src;
	size_t size;
	long nextpos;
	
	base.digsep = '\'';
	base.base = 10;
	ret = alu_get_reg_nodes( alu, base.regv, ALU_BASE_COUNT, 0 );
	
	
	if ( ret != 0 )
	{
		alu_error( ret );
		return ret;
	}
	
	ret = alu_get_reg_nodes( alu, lit.regv, ALU_LIT_COUNT, 0 );
	
	
	if ( ret != 0 )
	{
		alu_rem_reg_nodes( alu, base.regv, ALU_BASE_COUNT );
		alu_error( ret );
		return ret;
	}
	
	_src.src = &__src;
	_src.next = (alu_func_rdChar32_t)func_rdChar32;
	_src.nextpos = &nextpos;
	
	_dst.dst = &__dst;
	_dst.next = (alu_func_wrChar32_t)func_wrChar32;
	_dst.flip = (alu_func_flipstr_t)func_flipstr;
	
	for ( i = 0; pos_int[i]; ++i )
	{
		src = pos_int[i];
		size = strlen(src);
		switch ( src[1] )
		{
		case 'x': case 'X': base.base = 16; break;
		case 'b': case 'B': base.base = 2; break;
		default: base.base = 10;
		}
		
		nextpos = 0;
		__src.block = src;
		__src.bytes.used = strlen(src);
		__src.bytes.last = __src.bytes.used;
		__src.bytes.upto = size ? size : __src.bytes.used + 1;
		
		ret = alu_block_expand( &__dst, __src.bytes.upto * 2 );
		if ( ret != 0 )
			return ret;
		
		ret = reg_print_value( alu, _src, _dst, base, lit, print_anyways );
		
		
		if ( ret != 0 )
		{
			alu_error( ret );
			goto fail;
		}
		
		ret = uint_print_value( alu, _src, _dst, base, lit, print_anyways );
		
		
		if ( ret != 0 )
		{
			alu_error( ret );
			goto fail;
		}
		
		ret = int_print_value( alu, _src, _dst, base, lit, print_anyways );
		
		
		if ( ret != 0 )
		{
			alu_error( ret );
			goto fail;
		}
	}
	
	for ( i = 0; neg_int[i]; ++i )
	{
		src = neg_int[i];
		size = strlen(src);
		switch ( src[1] )
		{
		case 'x': case 'X': base.base = 16; break;
		case 'b': case 'B': base.base = 2; break;
		default: base.base = 10;
		}
		
		nextpos = 0;
		__src.block = src;
		__src.bytes.used = strlen(src);
		__src.bytes.last = __src.bytes.used;
		__src.bytes.upto = size ? size : __src.bytes.used + 1;
		
		ret = alu_block_expand( &__dst, __src.bytes.upto * 2 );
		
		if ( ret != 0 )
		{
			alu_error( ret );
			goto fail;
		}
		
		ret = int_print_value( alu, _src, _dst, base, lit, print_anyways );
		
		
		if ( ret != 0 )
		{
			alu_error( ret );
			goto fail;
		}
	}
	
	fail:
	alu_block_release( &__dst );
	return ret;
}

Sorry Hodor, still further no ideas on your failed linkage issue, if what I suggested and did don't fix it then you'll just have to try what ever you think of, at the most you'll only be editing the *.mak files so that should at least reduce the annoyance if you care enough to try. Let me know how it goes if you do try and even if you don't at least let me know if it's a lost cause trying to get you to compile it again.

Originally Posted by Structure

Makefile:2: *** missing separator. Stop - Stack Overflow

By that I assume you mean when under a target, this is supposed to be executed BEFORE any targets, or am I mistaken? Here's a slightly larger snippet:

Code:

COMPILE_EXE=$(CC) $(BIN_FLAGS) $1 $(COP)o $2 $3 $(RPATH_FLAG)
COMPILE_DLL=$(CC) $(LIB_FLAGS) $1 $(COP)o $2 $3 $(RPATH_FLAG)
COMPILE_OBJ=$(CC) $(SRC_FLAGS) $1 $(COP)o $2 -c $3

$(info PRJ_SRC_FILES = '$(PRJ_SRC_FILES)')

$(call mkdir,$(PRJ_EXT_DIR))
$(call github_clone,$(FBSTDC_DIR),$(PRJ_EXT_DIR),awsdert/fbstdc)
$(info $(call rebase,$(FBSTDC_DIR)))
$(shell $(call rebase,$(FBSTDC_DIR)))

info: .FORCE

As it turns out the stack smashing appears to actually be in main(), tried moving the call to later on and tried seeing what other group tests did, it still reported stack smashing, from what little research I did on stack smashing I can't see any particular reason for it to occur unless I misunderstood something, here's what main looks like:

Code:

int main()
{
	int ret = 0;
	uint_t preallocate = 32;
	//uint_t seed = time(NULL);
	bool print_anyways = false;
	
	alu_t _alu = {0}, *alu = &_alu;
	
	//print_limits();

	alu_printf( "Pre-allocating %u ALU registers...", preallocate );
	ret = alu_setup_reg( alu, preallocate, 0, 0 );
	
	if ( ret != 0 )
	{
		alu_error( ret );
		return EXIT_FAILURE;
	}

#if 1
	ret = compare( alu, print_anyways );
	
	if ( ret != 0 )
	{
		alu_error( ret );
		goto fail;
	}
#endif

#if 0
	ret = bitwise( alu, true, true, print_anyways );
	
	if ( ret != 0 )
	{
		alu_error( ret );
		goto fail;
	}
#endif

#if 0
	ret = mathmatical( alu, false, true, print_anyways );
	
	if ( ret != 0 )
	{
		alu_error( ret );
		goto fail;
	}
#endif

	ret = print_value( alu, true );
	
	if ( ret != 0 )
	{
		alu_error( ret );
		goto fail;
	}
	
#if 0
	for ( num = 0; num < 0x10; ++num )
		alu_printf( "%u", (seed = rng(seed)) );
#endif

	if ( ret != 0 )
		alu_error( ret );
		
		
	fail:
	
	(void)alu_vec_shrink( alu, 0, 0 );
	(void)memset( alu, 0, sizeof(alu_t) );
	
	return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}

Any ideas? Reminder of code source: GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs

I resolved it by putting an $(info) around the $(shell) part

First, a link to the project:
GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs
Now for the main part, I ran into an inconsistency between the results of multiplication, small numbers work fine but a larger number resulted in an empty value when the opposite should have been there, someone mind taking a look at alu_mul() (in alu_math.c) and seeing if they can find potential causes

Edit: Occurred to me just after hitting post that I could've just posted the code also:

Code:

int alu_mul( alu_t *alu, int num, int val )
{
	bool carry = 0;
	int ret = alu_check2( alu, num, val ), tmp = 0;
	alu_reg_t *N, *V, *T;
	alu_bit_t v = {0}, e;
	size_t bits = 0;
	
	if ( ret != 0 )
		return ret;
	
	ret = alu_get_reg( alu, &tmp, sizeof(size_t) );
	
	if ( ret != 0 )
		return ret;
	
	N = alu->regv + num;
	V = alu->regv + val;
	T = alu->regv + tmp;

	v = V->init;
	e = N->upto;
	
	for ( ; v.b < e.b; v = alu_bit_inc( v ), ++bits )
	{
		if ( *(v.S) & v.B )
		{
			(void)alu__shl( alu, num, bits );
			ret = alu_add( alu, tmp, num );
			bits = 0;
			
			if ( ret == EOVERFLOW )
				carry = true;
			else if ( ret != 0 )
				break;
		}
	}
	
	memcpy( N->part, T->part, alu->buff.perN );
	alu_rem_reg( alu, tmp );
	
	return carry ? EOVERFLOW : 0;
}

Managed to narrow the problematic line but unable to figure out a fix, used a fix that is slower to resolve the output temporarily:

Code:

int alu_mul( alu_t *alu, int num, int val )
{
	bool carry = 0;
	int ret = alu_check2( alu, num, val ), tmp = -1;
	alu_reg_t *V;
	alu_bit_t p, v = {0}, e;
	size_t bits = 0;
	
	if ( ret != 0 )
		return ret;
	
	ret = alu_get_reg( alu, &tmp, sizeof(size_t) );
	
	if ( ret != 0 )
		return ret;
	
	V = alu->regv + val;
	p = v = V->init;
	e = V->upto;
	
	alu__or( alu, tmp, num );
	alu_xor( alu, num, num );
	
	for ( ; v.b < e.b; v = alu_bit_inc( v ), ++bits )
	{
		if ( *(v.S) & v.B )
		{
			//(void)alu__shl( alu, tmp, bits );
			ret = alu_add( alu, num, tmp );
			bits = 0;
			
			if ( ret == EOVERFLOW )
				carry = true;
			else if ( ret == ENODATA )
				break;
			else if ( ret != 0 )
			{
				alu_error( ret );
				break;
			}
		}
		(void)alu__shl( alu, tmp, 1 );
	}
	
	alu_rem_reg( alu, tmp );
	
	return carry ? EOVERFLOW : ret;
}

As you can see I commented out the problematic line, did some tests with the shift function and I don't think that was the cause, I believe maybe the value of bits is somehow incorrect, any ideas are welcome

Found the cause, I forgot to check for the situation where the number of bits to move by was 0, after skipping the shift in that situation the erroneous output was resolved.