but first, i quote gcc info:

A new edition of the ISO C standard was published in 1999 as ISO/IEC
9899:1999, and is commonly known as “C99″. GCC has incomplete support
for this standard version; see
`http://gcc.gnu.org/gcc-4.3/c99status.html’ for details. To select this
standard, use `-std=c99′ or `-std=iso9899:1999′. (While in
development, drafts of this standard version were referred to as “C9X”.)

it was interesting to note that gcc prevented me from doing a file scope VLA
definition. see below.

stef@angela ~/git/trash/variable_length_arrays $ gcc -std=c99 -o vlatest vlatest.c
vlatest.c:5: error: variably modified 's3' at file scope

im rather satisfied with this so i’ll leave it as it is. observing the assemler
listing after the prolog suggested that the compiler puts in a lot of work to
support the variable length array:

1) allocating of a minimalist stack area for for the operation
2) then, subsequently computing the space needed to further subtract the esp.

… it’s almost as if alloca() has been inlined.

VLAs permit for a good clean code though. i havent read the entire c99 standard yet so i dont know the scopes and limitations for this feature. but if ever i care to use the c99 VLAs, the first thing i wanna know is how the compiler will generate code when i declare my variable length array at file scope with another file scope variable (hopefully, without the use of any libstdc).

in file scope:

char array1[10]; // static block at section .bss (compile time)
char array2[10] = {0}; // at .data section (compile time)

but if i say:

extern int size;
char array1[size];

how would the section be allocated since size is also unknown? i doubt they’ll place allocations in the startup runtime lib (since, hell im a broken record, size is unknown during startup) - and would array1[] still be allocated at .bss? (more like the heap since its runtime allocated but i’ll see soon enough)

i need to study up on this.

the extreme malevolent evil manifest with every intention to kill - i guess i knew instinctively. Manifest evil is not something I am given to commonly contemplating. I grew up with a religious fear of both God and the Devil. So this image and theme came as a disturbing revelation.

the science explained by wikipedia (http://en.wikipedia.org/wiki/Sleep_paralysis) is supposed to make me feel better and a little more educated… i guess. but im not feeling reassured anytime soon. infact, im writing this entry at 3:17 am - to just keep myself awake!

that is some freaky shit i just experienced.

[ teaching the mind to do tricks is painful ]

the past nights, i’ve covered Ohm’s law and have solved some beginner problems.BUT - the thing i found frustrating at first was determining if a specific circuit is series or parallel - especially in bigger circuits with multiple paths. anyway, i’m over that frustration now and i’m beginning to have that automatic mental ability of re-drawing a circuit in my mind so i can see things clearly.

[ kirchoff’s law ]

“The algebraic sum of the currents into any point of the circuit must equal the algebraic sum of the currents going out of that point”

and

“The algebraic sum of all voltages in a loop must equal zero”

the first sample circuit problem is outlined below: solve for the current across resistor R3.

i reached only up to the two equations part since the I1 terms of both equations could not cancel out each other.

stuck halfway…

i still had 2 unkowns (I1 and I2). turning to the book, it said i need to normalize I1 in such a way that subtraction of those two equations will cancel out the terms with I1 - multiplying the second equation by 4.

there are many more problems i plan to solve but i’ve had enough kirchoffs law for one day.

being your own teacher… is its own reward

i’ve been reading and learning about analog and digital electronics during my free time and during weekends. it has been a great learning experience and i wish i had a formal curriculum to follow with this gig. its been at most 4 years since i last used boolean algebra to this extent so im expecting things to be a bit rusty and wrong. i’m starting with the infamous 4 bit BCD to 7 segment since it’s the most basic, confidence boosting, hands-on activity i can think of.

[updates]

the problem with my initial kmaps was that they didn’t follow gray code. therefore, 00, 01, 10, 11 should have been 00, 01, 11, 00 wherein only a single bit changes everytime. a binary sequence from 01 to 10 changes two bits; 0 to 1, and 1 to 0 in their corresponding places.

i also noticed that the number of logic gates used to implement a 7 segment that displays 0x0-0xF is staggering and it would take up an exceedingly large space in my breadboard, so i lowered the digits it could display up to 9 only.

the figure below is my new truth table, with 10-15 as dont-cares.

which yields the following logic circuit for A to G.

but a simplification is still in order, mainly because there are combinations that yield a shorter sub-expression.

A = A + C + BD + B'D'
	
1) (A + C + BD + B'D')'              ; de morgan's
	
2) (A') (C') (B' + D') (B + D)       ; distribute
	
3) (A') (C') (B'B + B'D + BD' + D'D) ; theorem 16: A'A = 0
	
4) (A') (C') (B'D + BD')             ; A'B + AB' < => A xor B
	
5) ((A’) (C’) (B xor D))’            ; de morgan’s
	
6) A + C + (B xor D)’                ; final answer

assuming only single - 2 input cmos gates + sinle inverters

A + C + BD + B'D' = 6 gates
	
A + C + (B xor D)' = 4 gates

thats a savings of 2 logic gates!

the simplified XOR expression is very elegant, but i don’t have any CMOS xor gates in hand right now. so i’m sticking with the longer logic expressions which does not utilize an XOR operation.

update! update! update! update! update! update! update!

http://dfa.gov.ph/?p=3962

ain’t she the cutest!!!!!!?????? i’m soo… like… smitten! but geez! i can’t believe i’m in love with a damn drawing!

so let’s try to follow a simple “hello world” program to see how gcc makes ppc
programs. it’s compiled with no optimizations.

int procedure1(const char *string)
{
        printf(string);
        return 0;
}
	
int main(int argc, char *argv[])
{
        return procedure1(\"hello world\n\");
}

the V4 stack frame.

	SP---->	+---------------------------------------+
		| back chain to caller			| 0
		+---------------------------------------+
		| saved LR				| 4
		+---------------------------------------+
		| Parameter save area (P)		| 8
		+---------------------------------------+
		| Alloca space (A)			| 8+P
		+---------------------------------------+
		| Local variable space (L)		| 8+P+A
		+---------------------------------------+
		| saved CR (C)				| 8+P+A+L
		+---------------------------------------+
		| Save area for GP registers (G)	| 8+P+A+L+C
		+---------------------------------------+
		| Save area for FP registers (F)	| 8+P+A+L+C+G
		+---------------------------------------+
	old SP->| back chain to caller's caller		|
		+---------------------------------------+

the V4 Registers

r0 volatile, may be used by function linkage
r1 stack pointer
r2 reserved for system
r3 .. r4 volatile, pass 1st - 2nd int args, return 1st - 2nd ints
r5 .. r10 volatile, pass 3rd - 8th int args
r11 .. r12 volatile, may be used by function linkage
r13 small data area pointer
r14 .. r31 saved
f0 volatile
f1 volatile, pass 1st float arg, return 1st float
f2 .. f8 volatile, pass 2nd - 8th float args
f9 .. f13 volatile
f14 .. f30 saved
f31 saved, static chain if needed.
lr volatile, return address
ctr volatile
xer volatile
fpscr volatile*
cr0 volatile
cr1 volatile**
cr2 .. cr4 saved
cr5 .. cr7 volatile

* The VE, OE, UE, ZE, XE, NI, and RN (rounding mode) bits of the FPSCR may be
changed only by a called function such as fpsetround that has the documented
effect of changing them, the rest of the FPSCR is volatile.

** Bit 6 of the CR (CR1 floating point invalid exception bit) is set to 1 if a
variable argument function is passed floating point arguments in registers.

the PPC architecture does not have a push/pop instruction that implicitly
operates on the stack. as such, stack management could be a little more “hands
on” on PPC in comparison to intel. the stack frame convention above is defined
to support parameter passing, reserved registers (nonvolatile) preservation and
local variables. each function which either calls another function or modifies
saved register must create a stack frame from memory set aside for use as a
stack defined by the r1 register (r1 = sp).

the stwu instruction assures that stack frame allocation is atomic. stack
space is allocated and the sp (r1) is updated in just one instruction.

parameter passing. ppc passes function parameters thru registers rather than
pushing them all in the stack.

<procedure1>
stwu    r1,-32(r1)  ; save former and allocate a new stack frame
mflr    r0          ; return addr of procedure1()
stw     r31,28(r1)  ; save r31
stw     r0,36(r1)   ; save r0
mr      r31,r1      ; mirror sp
stw     r3,8(r31)   ; save char * to stack
lwz     r3,8(r31)   ; argument to printf
bl      10010a00

li      r0,0        ; r0 = 0
mr      r3,r0       ; r3 = 0 = return value
lwz     r11,0(r1)   ; access back chain
lwz     r0,4(r11)   ; access return address
mtlr    r0          ; update link register with return addr of procedure1()
lwz     r31,-4(r11) ; restore r31
mr      r1,r11      ; restore caller’s stack
blr                 ; return to caller
	
<main>
stwu    r1,-32(r1)      ; save former frame and allocate a new stack frame
mflr    r0              ; return address of main()
stw     r31,28(r1)      ; save r31
stw     r0,36(r1)       ; save link register
mr      r31,r1          ; mirror sp
stw     r3,8(r31)       ; save r3
stw     r4,12(r31)      ; save r4
lis     r9,4096         ; lower 16 bits of string addr
addi    r3,r9,2176      ; higher 16 bits of string addr
bl      10000434
 ; procedure1(char *)
mr      r0,r3           ; r0 = return val of procedure1()
mr      r3,r0           ; r3 = 0 (retval)
lwz     r11,0(r1)       ; access back chain
lwz     r0,4(r11)       ; access return address
mtlr    r0              ; update link register
lwz     r31,-4(r11)     ; restore r31
mr      r1,r11          ; restore stack frame
blr                     ; leave main()

next time, we’ll delve more deeper and see how to access system calls directly
and how these system calls are implemented.