Smaller C is a simple and small single-pass C compiler

Hey,

I'm working on a MikeOS C library and I'm having trouble with the lack of long type that is needed for some functions. It would also be nice to support floating point in printf and other C functions. Do you have any plans to add the long or float types for 16-bit binaries?

If not, perhaps you could explain the problems and I'll try to implement it.

By the way, I've notice that using a floating point operation in 16-bit mode causes the compiler to emit a symbol such as: __addsf3

Could I add floating point support at a library level by providing my own functions for these symbols?

Thanks

Hello, I was looking for a C compiler for an 80C188 processor and this one came to be a really nice one. However, and after looking in the Wiki, I found something that might cripple my intentions. This board happens to have a 128k RAM and 512k flash. If the flat image produced by the compiler ends up in the read only map of the processor (in the flash), some code (ie global rw variables) will become read only. I was looking the smlrl.c file but I couldn't tell how to force that section to be in other place (for my purposes, at the bottom of the memory map, 0x0). I know that I'll need an initializer stub that should run prior to my code.

So, my question is, it possible to achieve this without a lot of fiddling in the source file of smlrl? Or maybe some kind of hack using other tool alongside SmallerC?

Sorry if this is not a proper "issue", but I wanted to ask directly to the author.

Hi,

Recently I've been developing a 16-bit library/archive. The library is written in assembly (NASM) and makes calls to immediate values. It assemblies into an elf object just fine, but when I link it with smlrl, I get an Unhandled exception! error. I've been able to trace the problem back to the call instructions. I'm not sure if I'm making a silly mistake or if it's a genuine problem, but it seems that the linker can't handle handle my 16-bit calls!

Below is the readout of the build process:

smlrc.exe -seg16 -seg16 -SI .\../include test.c test.asm
nasm.exe -f elf test.asm -o test.o
smlrl.exe -flat16 -tiny -origin 0x3200 -entry _main test.o mlib.a -o test.bin

Unhandled exception!

Executed command failed

I can give more information if needed. Any help would be appreciated!

is it possible to create an MZ EXE with both 16-bit and 32-bit code segments? (for example, you have a stub that enters Protected Mode, calls into your main application to do some work, then returns to DOS) without DPMI?

Hi,

While compiling an ELF loader on Windows, I ran into the following errors:

Error in "elf-loader/elf-module.c" (38:41)
Unexpected declaration or expression of type void

Failed command 'smlrc.exe -seg32 -winstack -nopp elf-loader/elf-module.i elf-loader/elf-module.asm'

The file (elf-loader/elf-module.c) is as follows:

/*
 * ELF loadable modules
 *
 * 12 Feb 2011, Yury Ossadchy
 */
#include <string.h>

#include "elf-module-private.h"

static char *elf_module_sym_name(elf_module_t *elf, int offs)
{
    return elf->names + offs;
}

static void elf_module_layout(elf_module_t *elf)
{
    int i;
    Elf_Shdr *shdr;

    for (i = 1; i < elf->header->e_shnum; i++) {
	shdr = &elf->sections[i];

	if (!(shdr->sh_flags & SHF_ALLOC))
	    continue;

	shdr->sh_addr = shdr->sh_addralign
	    ? (elf->size + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1)
	    : elf->size;
	elf->size = shdr->sh_addr + shdr->sh_size;
    }
}

static void *elf_module_get_ptr(elf_module_t *elf, Elf_Addr addr)
{
    return elf->start + addr;
}

static void *elf_module_sec_ptr(elf_module_t *elf, Elf_Shdr *shdr)
{
    return (void *) elf->header + shdr->sh_offset;
}

static int elf_module_reloc(elf_module_t *elf)
{
    int i;
    Elf_Shdr *shdr = &elf->sections[0];

    for (i = 0; i < elf->header->e_shnum; i++) {
	switch (shdr->sh_type) {
	case SHT_REL:
	    elf_module_reloc_section(elf, shdr);
	    break;
	case SHT_RELA:
	    elf_module_reloca_section(elf, shdr);
	    break;
	}
	shdr++;
    }
    return 0;
}

static int elf_module_link(elf_module_t *elf, elf_module_link_cbs_t *cbs)
{
    int err;
    int n = elf->symtab->sh_size / sizeof(Elf_Sym);
    Elf_Sym *sym;
    Elf_Sym *symtab = elf_module_sec_ptr(elf, elf->symtab);
    Elf_Sym *end = &symtab[n];

    for (sym = &symtab[1]; sym < end; sym++) {
	switch (sym->st_shndx) {
	case SHN_COMMON:
	    return -EME_NOEXEC;

	case SHN_ABS:
	    break;
	
	case SHN_UNDEF:
	    /* resolve external symbol */
	    sym->st_value = (Elf_Addr)
		cbs->resolve(elf, elf_module_sym_name(elf, sym->st_name));
	    if (!sym->st_value)
		return -EME_UNDEFINED_REFERENCE;
	    break;

	default:
	    /* bind to physical section location and define as accessible symbol */
	    sym->st_value += (Elf_Addr) elf_module_get_ptr(elf,
		elf->sections[sym->st_shndx].sh_addr);

	    if (ELF_SYM_TYPE(sym->st_info) != STT_SECTION) {
		err = cbs->define(elf, elf_module_sym_name(elf, sym->st_name),
		    (void *) sym->st_value);
		if (err < 0)
		    return err;
	    }
	}
    }
    return 0;
}

int elf_module_init(elf_module_t *elf, void *data, size_t size)
{
    int i;

    elf->header = data;

    if (memcmp(elf->header->e_ident, ELF_MAGIC, sizeof(ELF_MAGIC) - 1)
	|| !elf_module_check_machine(elf)) {
	return -EME_NOEXEC;
    }

    elf->sections = data + elf->header->e_shoff;
    elf->strings = data + elf->sections[elf->header->e_shstrndx].sh_offset;
    elf->size = 0;

    /* section 0 is reserved */
    for (i = 1; i < elf->header->e_shnum; i++) {
	Elf_Shdr *shdr = &elf->sections[i];

	if (shdr->sh_type == SHT_SYMTAB) {
	    elf->symtab = &elf->sections[i];
	    elf->strtab = &elf->sections[elf->sections[i].sh_link];
	    elf->names = data + elf->strtab->sh_offset;
	}
    }

    elf_module_layout(elf);
    return 0;
}

size_t elf_module_get_size(elf_module_t *elf)
{
    return elf->size;
}

void elf_module_set_data(elf_module_t *elf, void *data)
{
    elf->data = data;
}

void *elf_module_get_data(elf_module_t *elf)
{
    return elf->data;
}

int elf_module_load(elf_module_t *elf, void *dest, elf_module_link_cbs_t *cbs)
{
    int i;
    int res;
    Elf_Shdr *shdr;

    elf->start = dest;

    for (i = 1; i < elf->header->e_shnum; i++) {
	shdr = &elf->sections[i];

	if (!(shdr->sh_flags & SHF_ALLOC))
	    continue;

	memcpy(elf_module_get_ptr(elf, shdr->sh_addr),
	    (void *) elf->header + shdr->sh_offset, shdr->sh_size);
    }

    res = elf_module_link(elf, cbs);
    if (res < 0)
	goto out;

    res = elf_module_reloc(elf);
out:
    return res;
}

void *elf_module_lookup_symbol(elf_module_t *elf, char *name)
{
    int i;
    int n = elf->symtab->sh_size / sizeof(Elf_Sym);
    Elf_Sym *sym = (void *) elf->header + elf->symtab->sh_offset + sizeof(Elf_Sym);

    for (i = 1; i < n; i++, sym++) {
	switch (sym->st_shndx) {
	case SHN_ABS:
	    break;

	case SHN_UNDEF:
	    break;

	default:
	    if (!strcmp(elf_module_sym_name(elf, sym->st_name), name))
		return (void *) sym->st_value;
	}
    }
    return NULL;
}

Line 38 is the function elf_module_get_ptr.

I would like to know whether Win16 support is doable: whether SmallerC knows how to generate ASM code that can then be assembled (by NASM, etc) to Win16 NE executable, and be possibly linked to other Win16 dlls.

Hi!

It is explicitly stated in the docs that the far pointers are unsupported. Yet its a pity, as it prevents the building of many existing DOS projects with this compiler. So I'd like to know if the support is planned, and if not - why, and how difficult is it to add such a support? Given that the huge pointers are already supported, what is the remaining problems that prevents the support of the far pointers?

Hello, First off I would say Great Work! This is possibly the only compiler that satisfies my needs (less bloat, simple and loose syntax, NASM compatible etc.)
I have been recently playing with this compiler for DOS development, sadly it does not support (until now) the parametrized macros, which is needed for functions like va_end, va_start and va_arg which are in turn needed for functions like printf. Is there a workaround? -ALLDESP

I’m trying to port mksh to SmallerC, and it fails at even detecting the compiler because the compiler driver lacks the option -E (preprocess only).

$ cat >conftest.c <<\EOF
const char *
#if defined(__ICC) || defined(__INTEL_COMPILER)
ct="icc"
#elif defined(__xlC__) || defined(__IBMC__)
ct="xlc"
#elif defined(__SUNPRO_C)
ct="sunpro"
#elif defined(__SMALLER_C__)
ct="smlrc"
#elif defined(__neatcc__)
ct="neatcc"
#elif defined(__lacc__)
ct="lacc"
#elif defined(__ACK__)
ct="ack"
#elif defined(__BORLANDC__)
ct="bcc"
#elif defined(__WATCOMC__)
ct="watcom"
#elif defined(__MWERKS__)
ct="metrowerks"
#elif defined(__HP_cc)
ct="hpcc"
#elif defined(__DECC) || (defined(__osf__) && !defined(__GNUC__))
ct="dec"
#elif defined(__PGI)
ct="pgi"
#elif defined(__DMC__)
ct="dmc"
#elif defined(_MSC_VER)
ct="msc"
#elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
ct="adsp"
#elif defined(__IAR_SYSTEMS_ICC__)
ct="iar"
#elif defined(SDCC)
ct="sdcc"
#elif defined(__PCC__)
ct="pcc"
#elif defined(__TenDRA__)
ct="tendra"
#elif defined(__TINYC__)
ct="tcc"
#elif defined(__llvm__) && defined(__clang__)
ct="clang"
#elif defined(__NWCC__)
ct="nwcc"
#elif defined(__GNUC__)
ct="gcc"
#elif defined(_COMPILER_VERSION)
ct="mipspro"
#elif defined(__sgi)
ct="mipspro"
#elif defined(__hpux) || defined(__hpua)
ct="hpcc"
#elif defined(__ultrix)
ct="ucode"
#elif defined(__USLC__)
ct="uslc"
#elif defined(__LCC__)
ct="lcc"
#elif defined(MKSH_MAYBE_KENCC)
/* and none of the above matches */
ct="kencc"
#else
ct="unknown"
#endif
;
const char *
#if defined(__KLIBC__) && !defined(__OS2__)
et="klibc"
#else
et="unknown"
#endif
;
EOF
$ smlrcc -linux -E  -I. -I'/root/mksh'  -DMKSH_BUILDSH -D_GNU_SOURCE -DSETUID_CAN_FAIL_WITH_EAGAIN  conftest.c

Invalid or unsupported command line option '-E'

I created a project:

https://c-testsuite.github.io/ https://github.com/c-testsuite/c-testsuite

and wondered if you would like to join in, things are sparse and need organizing, but perhaps you understand what I am aiming for.

I use clang(with fsanitize=address) to compile this project. when I call $ make I receive:

awk -v l=/opt/SmallerC/v0100/srclib/ '/.$/{$0=l$0}{print}' /opt/SmallerC/v0100/srclib/lcds.txt > lcds.op ./smlrcc -SI /opt/SmallerC/v0100/include -I /opt/SmallerC/v0100/srclib @lcds.op

==15851==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 1400 byte(s) in 1 object(s) allocated from: #0 0x4da2e0 in realloc (/opt/SmallerC/smlrcc+0x4da2e0) #1 0x51445b in fatargs /opt/SmallerC/v0100/smlrcc.c:550:23

SUMMARY: AddressSanitizer: 1400 byte(s) leaked in 1 allocation(s). /opt/SmallerC/v0100/../common.mk:42: recipe for target 'lcds.a' failed make: *** [lcds.a] Error 1 rm lcds.op

My code is based on Pull request 33 from aleexmaftei.

Changes:

• Implementation of "-8086" flag on smlrc and smlrcc
• Implementation of macro __SMALLER_C_8086__, setted by "-8086" flag
• This new flag can be used with 32-bit modes, but generate bigger code without 386 otimizations on 16 bits.
• Create a alternative lcds.a library with 8086 code only, named lcds86.a
• When "-8086" and "-tiny"/"-dost" flags active, use new "lcds86.a" instead "lcds.a"
• Creation of "Use8086InstrOnly" global variable on smlrc and smlrcc, setted by "-8086" flag
• When activated change generation of (MOVZX, MOVSX, Bit operations, SETxx instructions, etc) to 8086 compatible equivalents.