vasm dead code removal

[dalton]

Does anybody know if there is a way to tell vasm what code belongs to a specific routine? So that routines that are never called don't get included in the compiled exe.

[phx]

Unfortunately vasm cannot help you here. Is there a solution for that on other assemblers?

I would suggest to put your routines into a static linker library, so the linker (vlink) will only include those which are really needed. Use a separate object module for each routine to make it work.

[hooverphonique]

gcc has features (-ffunction-sections/-fdata-sections/-gc-sections) where it puts each function/data item in its own section and then the linker automatically discards unreferenced sections.. I know it's not vasm, but maybe of interest anyway..

[phx]

Originally Posted by hooverphonique

gcc has features (-ffunction-sections/-fdata-sections/-gc-sections) where it puts each function/data item in its own section

Indeed, but this will only work for a C source.
The assembler doesn't know where a function starts or ends, unless there is a directive which defines that.

[hooverphonique]

Originally Posted by phx

The assembler doesn't know where a function starts or ends, unless there is a directive which defines that.

you're right, of course.. my mind went wandering, I guess

[dalton]

Thanks for your replies!

Haven't seen any assembler which can do this. It would be a useful feature to have, as you could spend less time organizing routines into different files.

Perhaps not applicable to all types of code. But in most cases a function is just a function with a start and an end so syntactically it could be implemented with some kind of begin/end directives.

[phx]

Originally Posted by dalton

Perhaps not applicable to all types of code. But in most cases a function is just a function with a start and an end so syntactically it could be implemented with some kind of begin/end directives.

Correct. That's what I was thinking. Then the assembler would only have to count the number of references to each label. When all labels between the start and end directive have zero references it is safe to discard the routine. Could be done...

EDIT: Maybe not that easy as I wrote first: References to labels between start and end from a location between the same start and end directives should not be counted, of course.

[Apollo]

Does an assembler have an understanding of the program flow? For me this the difference with a higher languages compiler.

[phx]

Originally Posted by Apollo

Does an assembler have an understanding of the program flow?

No, it has not.
But it can easily see whether a label is referenced from somewhere, while parsing operands.

[StingRay]

Easily is relative I guess.

lea START-4(pc),a0
bsr GetHunk
; code to store hunk starts follows
...
; lots of other code
; a2: hunk starts
move.l (a2)+,d0
add.l #SOMECODE-STARTOFFSET,d0 ; label access, trivial?


etc. There are so many ways to disguise label referencing that I would not call it an easy task to detect any references.

[phx]

Hm... you're right of course. Maybe I would have realized that when I started working on it.

It probably makes no sense to implement something like that into an assembler.

[StingRay]

In my opinion this is stuff for a HLL compiler anyway and neither needed nor required for assembler code as for asm the coder should take care of the code on his own.

[dalton]

Perhaps not applicable to all types of code.

The use case I had in mind was when building some asm source together with a c source. The asm source would be fairly large and hold for instance routines for drawing different graphics primitives. Then I would like only the routines that are actually called from the c-context to be included in the exe.

For me it could be as simple as declaring that some asm-code should be left out if a specific label is never referenced.

Could look like this:

draw_line:

    IFREFERENCED draw_line

    ; awesome line drawing routine goes here
    rts

    ENDC

[dalton]

Of course it would be good also to have a directive for explicitly referencing a label too. That can be used if you want to explicitly tell the assembler that you've referenced a label but the reference itself is hidden in trickery.

[StingRay]

Originally Posted by dalton

Then I would like only the routines that are actually called from the c-context to be included in the exe.

Shouldn't the linker take care of that already?

[dalton]

As far as I understand, the linker cannot remove parts of an included asm source. To remove code you need to put each routine in a separate file and compile an object for each of them. Then only the objects that are used will be included.

[phx]

Your example to link with a C program looks like the ideal case for putting your assembler routines as separate objects into a static link library.

Why can't you do that? Maybe because your huge assembler source is already written and it is much work to divide it into small pieces?

[dalton]

Yes, this is typically how my legacy sources are organized. It is not incredibly hard to split them into many different files. But it's not much fun, and I guess that a feature like this could be useful also when coding pure asm.

I don't think there are any really convenient ways of maintaining function libraries in asm, and in the end the purpose of the assembler is to make life easier for us.