Skip to contentSkip to conversation

Per option CFLAGS?

DISCUSSION Rene Herman 4 participants 8 messages Sep 14, 2007 – Sep 15, 2007

lore
Share & tools
lore
#0 lore raw

Hi Kai, Sam.

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

and a regular Makefile

===
foo2000-objs := foo2000.o
foo2001-objs := foo2001.o

obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
obj-$(CONFIG_SND_F002001) += snd-foo2001.o
===

That #include is a little lame though. Is there a nicer way? I noticed the per-file CFLAGS, but given that it's one source file for both, that doesn't fit.

Rene.

#1 lore raw
Quoted 20 lines · Rene Herman

Hi Kai, Sam.

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

and a regular Makefile

===
foo2000-objs := foo2000.o
foo2001-objs := foo2001.o

Quoted 8 lines

obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
obj-$(CONFIG_SND_F002001) += snd-foo2001.o
===

That #include is a little lame though. Is there a nicer way? I noticed the per-file CFLAGS, but given that it's one source file for both, that doesn't fit.

The stub source file is usually considered a good way to do this.

-hpa

#2 lore raw
Quoted 24 lines · H. Peter Anvin
Quoted 22 lines · Rene Herman

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

and a regular Makefile

===
foo2000-objs := foo2000.o
foo2001-objs := foo2001.o

obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
obj-$(CONFIG_SND_F002001) += snd-foo2001.o
===

Quoted 6 lines
Quoted 4 lines

That #include is a little lame though. Is there a nicer way? I noticed the per-file CFLAGS, but given that it's one source file for both, that doesn't fit.

The stub source file is usually considered a good way to do this.

Mmm. If I'll have to live with it, I can, but thought I'd ask if there was some nice build trickery available instead.

Rene.

#3 lore raw
Quoted 26 lines · Rene Herman
Quoted 24 lines · H. Peter Anvin
Quoted 22 lines · Rene Herman

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

and a regular Makefile

===
foo2000-objs := foo2000.o
foo2001-objs := foo2001.o

obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
obj-$(CONFIG_SND_F002001) += snd-foo2001.o
===

Quoted 8 lines
Quoted 5 lines
Quoted 4 lines

That #include is a little lame though. Is there a nicer way? I noticed the per-file CFLAGS, but given that it's one source file for both, that doesn't fit.

The stub source file is usually considered a good way to do this.

Mmm. If I'll have to live with it, I can, but thought I'd ask if there was some nice build trickery available instead.

The usual trick is to create _three_ modules:

Two with the foo2000 and foo2001 specific parts, and a third one with all code used by both.

Or if foo2000 and foo2001 differ only in small details, create one snd-foo200x module supporting both at the same time.

Quoted 1 line

Rene.

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#4 lore raw
Quoted 15 lines · Adrian Bunk
Quoted 14 lines · Rene Herman
Quoted 12 lines · H. Peter Anvin
Quoted 11 lines · Rene Herman

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

[ ... ]

Quoted 11 lines
Quoted 3 lines
Quoted 1 line

The stub source file is usually considered a good way to do this.

Mmm. If I'll have to live with it, I can, but thought I'd ask if there was some nice build trickery available instead.

The usual trick is to create _three_ modules:

Two with the foo2000 and foo2001 specific parts, and a third one with all code used by both.

Or if foo2000 and foo2001 differ only in small details, create one snd-foo200x module supporting both at the same time.

Thanks for the comment. Yes, first would be massive overkill in this case and second somewhat annoying as one of the differences is support for different resources (IRQs) among the two versions, whereas I'm checking the validity of the passed in values at a time I do not know which version I'm looking at yet -- knowing that requires having talked to the hardware.

Can do, but for now it seems like the two seperate modules might be cleaner. Can keep things much more straighforward that way by just redefining a bunch of #defines.

I'll just do the split version first and if someone really wants me to, I'll merge them after all...

Rene

#5 lore raw
Quoted 29 lines · Rene Herman
Quoted 15 lines · Adrian Bunk
Quoted 14 lines · Rene Herman
Quoted 12 lines · H. Peter Anvin
Quoted 11 lines · Rene Herman

I have a single file foo.c that I want to generate two (ALSA) modules from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or FOO2001 defined.

I can do this, and ALSA does this a few times, by providing dummy foo2000.c and foo2001.c files, like:

=== foo2000.c
#define FOO2000
#include "foo.c"
===

[ ... ]

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

The stub source file is usually considered a good way to do this.

Mmm. If I'll have to live with it, I can, but thought I'd ask if there was some nice build trickery available instead.

The usual trick is to create _three_ modules:
Two with the foo2000 and foo2001 specific parts, and a third one with all code used by both.
Or if foo2000 and foo2001 differ only in small details, create one snd-foo200x module supporting both at the same time.

Quoted 5 lines

Thanks for the comment. Yes, first would be massive overkill in this case and second somewhat annoying as one of the differences is support for different resources (IRQs) among the two versions, whereas I'm checking the validity of the passed in values at a time I do not know which version I'm looking at yet -- knowing that requires having talked to the hardware.

I'm not getting this point.

Consider both snd-foo2000 and snd-foo2001 are compiled statically into the kernel - somehow one of them must realize quite early that it's not responsible for the device.

And however this is done, it should similarly work in one module supporting both.

Quoted 8 lines

Can do, but for now it seems like the two seperate modules might be cleaner. Can keep things much more straighforward that way by just redefining a bunch of #defines.

I'll just do the split version first and if someone really wants me to, I'll merge them after all...

Rene

cu
Adrian

Signature · 4 lines
       "Is there not promise of rain?" Ling Tan asked suddenly out
        of the darkness. There had been need of rain for many days.
       "Only a promise," Lao Er said.
                                       Pearl S. Buck - Dragon Seed
#6 lore raw
In reply to Rene Herman
Quoted 10 lines · Rene Herman
Quoted 9 lines · Adrian Bunk
Quoted 3 lines
Quoted 1 line

The stub source file is usually considered a good way to do this.

Mmm. If I'll have to live with it, I can, but thought I'd ask if there was some nice build trickery available instead.

The usual trick is to create _three_ modules:

Two with the foo2000 and foo2001 specific parts, and a third one with all code used by both.

Quoted 8 lines
Quoted 2 lines

Or if foo2000 and foo2001 differ only in small details, create one snd-foo200x module supporting both at the same time.

Thanks for the comment. Yes, first would be massive overkill in this case and second somewhat annoying as one of the differences is support for different resources (IRQs) among the two versions, whereas I'm checking the validity of the passed in values at a time I do not know which version I'm looking at yet -- knowing that requires having talked to the hardware.

If I understood you right, this is PCI, USB or other kind of devices where module is selected according to PCI/USB/whatever IDs.

You thinking is - if module foo2000 is loaded, this is definitely a 2000 device and you can "check the validity of the passed in values" for the device 2000 now.

Correct me if I'm wrong.

But you can do absolutely the same at runtime in unified driver, since PCI/USB/whatever IDs are accessible to the driver.

Two drivers will most likely have code duplication.

Unified driver will be harder to read and maintain because of all ifs/switch's/function pointers you need.

The choice depends on *how much* maintainability pain you can tolerate by taking "unified code" path.

Quoted 1 line

Can do, but for now it seems like the two seperate modules might be cleaner.

Can you give a bit more info what the dirrefences between devices are in this particular cases?
--
vda

#7 lore raw
Quoted 2 lines · Denys Vlasenko

Can you give a bit more info what the dirrefences between devices are in this particular cases?

It's ISA. Thanks, but never mind guys, I only wanted to know something about kbuild.

Rene.