tools/envcrc.c: use the target sizeof rather than build

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This introduces a sizeof.sh script to calculate the required sizeof() value of any type with any compiler.

tools/sizeof.sh new file +15 -0

@@ -0,0 +1,35 @@
+#!/bin/sh
+# Get the sizeof(type) for a compiler
+
+type="$*"
+CC=${CC:-gcc}
+
+if [ -z "$type" ] ; then
+	echo "Usage: sizeof.sh <type>" 1>&2
+	exit 1
+fi
+
+test_size() {
+	cat <<-EOF > sizeof.c
+	typedef $type ac__type_sizeof_;
+	int main() {

Quoted 5 lines · In message <[email protected]> you wrote:

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This introduces a sizeof.sh script to calculate the required sizeof() value of any type with any compiler.

It seems this script requires up to 64 runs of the C compiler. I consider this pretty expensive. Isn't there a cheaper way to do that?

Consider the simple logic used to decide between 32 versus 64 bit pointer types - shouldn't this be sufficient here, too?

Quoted 23 lines

tools/sizeof.sh new file +16 -0

@@ -0,0 +1,35 @@
+#!/bin/sh
+# Get the sizeof(type) for a compiler
+
+type="$*"
+CC=${CC:-gcc}
+
+if [ -z "$type" ] ; then
+	echo "Usage: sizeof.sh <type>" 1>&2
+	exit 1
+fi
+
+test_size() {
+	cat <<-EOF > sizeof.c
+	typedef $type ac__type_sizeof_;
+	int main() {
+		static int test_array [1 - 2 * !(((long int) (sizeof

(ac__type_sizeof_))) <= $size)]; + test_array [0] = 0;

tools/sizeof.sh new file +3 -0

+		return 0;
+	}
+	EOF

tools/sizeof.sh line 25

Quoted 5 lines

tools/sizeof.sh new file +5 -0

+	${CC} -c sizeof.c >/dev/null 2>&1
+	ret=$?
+	rm -f sizeof.[co]
+	return $ret
+}

Are there no Copyrights / License conditions attached to this code? Where exactly is it coming from?

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This introduces a sizeof.sh script to calculate the required sizeof() value of any type with any compiler.

Signed-off-by Mike Frysinger <[email protected]>

---
Changes:
- adds copyright/license
- increase limit to 512
- increment by 4 bytes to find "32bit naturals" faster:
(old/new # = number of times gcc is called)
type | sizeof | old | new
char | 1 | 1 | 5
short | 2 | 2 | 4
int | 4 | 4 | 2
long | 8 | 8 | 3
double | 8 | 8 | 3

Quoted 7 lines · In message <[email protected]> you wrote:

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This introduces a sizeof.sh script to calculate the required sizeof() value of any type with any compiler.

Signed-off-by Mike Frysinger <[email protected]>

Quoted 12 lines

---
Changes:
- adds copyright/license
- increase limit to 512
- increment by 4 bytes to find "32bit naturals" faster:
(old/new # = number of times gcc is called)
type | sizeof | old | new
char | 1 | 1 | 5
short | 2 | 2 | 4
int | 4 | 4 | 2
long | 8 | 8 | 3
double | 8 | 8 | 3

Sorry, but I still think this is serious overkill which just slows down the build process.

We need exactly one single case of this, i. e. sizeof(long).

And
instead of tricking around all this here, I think we should rather use somthing like "u32" in the code.

Quoted 4 lines

And
instead of tricking around all this here, I think we should rather use somthing like "u32" in the code.

if the value in question represents a CRC32, then that's what should have been used in the first place ...

Quoted 6 lines · In message <[email protected]> you wrote:

Quoted 3 lines

And
instead of tricking around all this here, I think we should rather use somthing like "u32" in the code.

if the value in question represents a CRC32, then that's what should have been used in the first place ...

Indeed. So please let's focus on fixing the cause of the problem instead of adding scripts to work around it, slowly.

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This converts all unsigned long stuff related to crc32 to uint32_t types. Compile tested only: output of ./tools/envcrc when run on a 32bit build system matches that of a 64bit build system.

Quoted 6 lines · Mike Frysinger

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This converts all unsigned long stuff related to crc32 to uint32_t types. Compile tested only: output of ./tools/envcrc when run on a 32bit build system matches that of a 64bit build system.

ping
-mike

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This converts all unsigned long stuff related to crc32 to uint32_t types. Compile tested only: output of ./tools/envcrc when run on a 32bit build system matches that of a 64bit build system.

Signed-off-by Mike Frysinger <[email protected]>

---

The envcrc.c does sizeof(unsigned long) when calculating the crc, but this is done with the build toolchain instead of the target toolchain, so if the build is a 64bit system but the target is 32bits, the size will obviously be wrong. This introduces a sizeof.sh script to calculate the required sizeof() value of any type with any compiler.

Signed-off-by Mike Frysinger <[email protected]>

tools/sizeof.sh new file +25 -0

new file mode 100755
index 0000000..e17596c
@@ -0,0 +1,35 @@
+#!/bin/sh
+# Get the sizeof(type) for a compiler
+
+type="$*"
+CC=${CC:-gcc}
+
+if [ -z "$type" ] ; then
+	echo "Usage: sizeof.sh <type>" 1>&2
+	exit 1
+fi
+
+test_size() {
+	cat <<-EOF > sizeof.c
+	typedef $type ac__type_sizeof_;
+	int main() {
+		static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $size)];
+		test_array [0] = 0;
+		return 0;
+	}
+	EOF
+	${CC} -c sizeof.c >/dev/null 2>&1
+	ret=$?
+	rm -f sizeof.[co]
+	return $ret
+}

Cool script, which reminds me about something: Is it possible to define a script that can output if the cpu is Big Endian or Little Endian?