From: SourceForge.net <no...@so...> - 2012-04-30 07:15:28
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Tracker Item Submitted) made by You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Lisandro Pin () Assigned to: Nobody/Anonymous (nobody) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |
From: SourceForge.net <no...@so...> - 2012-04-30 07:17:09
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Comment added) made by You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Lisandro Pin () Assigned to: Nobody/Anonymous (nobody) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- >Comment By: Lisandro Pin () Date: 2012-04-30 00:17 Message: Sorry, the second code snippet should read: unsigned char x = digit[currentDigit]; x = x & !DIGIT_LEFTCOMMA_MASK; ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |
From: SourceForge.net <no...@so...> - 2012-04-30 07:42:35
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Comment added) made by tecodev You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Lisandro Pin () Assigned to: Nobody/Anonymous (nobody) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- >Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:42 Message: > x = x & !DIGIT_LEFTCOMMA_MASK; Beware: !0x20 == 0. You want ~0x20 = 0xffdf. I will investigate your additional comments later, but this should help you get on. Hope that helps, Raphael ---------------------------------------------------------------------- Comment By: Lisandro Pin () Date: 2012-04-30 00:17 Message: Sorry, the second code snippet should read: unsigned char x = digit[currentDigit]; x = x & !DIGIT_LEFTCOMMA_MASK; ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |
From: SourceForge.net <no...@so...> - 2012-04-30 07:45:27
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Comment added) made by epetrich You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Lisandro Pin () Assigned to: Nobody/Anonymous (nobody) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- >Comment By: Erik Petrich (epetrich) Date: 2012-04-30 00:45 Message: I think you should be using the compliment operator instead: unsigned char x = digit[currentDigit]; x = x & ~DIGIT_LEFTCOMMA_MASK; The ! operator is a boolean operator; it considers whether its operand as a whole is zero or non-zero. Since 0x20 is a non-zero value, the result of !0x20 equal 0. Thus x will always end up with the value 0. That x was not assigned is not necessarily a bug; if sdcc knows it has a constant value, the assignment itself may be optimized away and any references to x would be replaced with the constant. ---------------------------------------------------------------------- Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:42 Message: > x = x & !DIGIT_LEFTCOMMA_MASK; Beware: !0x20 == 0. You want ~0x20 = 0xffdf. I will investigate your additional comments later, but this should help you get on. Hope that helps, Raphael ---------------------------------------------------------------------- Comment By: Lisandro Pin () Date: 2012-04-30 00:17 Message: Sorry, the second code snippet should read: unsigned char x = digit[currentDigit]; x = x & !DIGIT_LEFTCOMMA_MASK; ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |
From: SourceForge.net <no...@so...> - 2012-04-30 07:55:01
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Comment added) made by tecodev You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target >Group: non bugs >Status: Closed >Resolution: Invalid Priority: 5 Private: No Submitted By: Lisandro Pin () >Assigned to: Raphael Neider (tecodev) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- >Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:55 Message: I just confirmed that int do_neg(int v) { int x = v; x = x & OP 0x20; /* OP = ! or ~ */ return x; } compiles properly in both cases (return 0; or return v&0xffdf;), so I close this. ---------------------------------------------------------------------- Comment By: Erik Petrich (epetrich) Date: 2012-04-30 00:45 Message: I think you should be using the compliment operator instead: unsigned char x = digit[currentDigit]; x = x & ~DIGIT_LEFTCOMMA_MASK; The ! operator is a boolean operator; it considers whether its operand as a whole is zero or non-zero. Since 0x20 is a non-zero value, the result of !0x20 equal 0. Thus x will always end up with the value 0. That x was not assigned is not necessarily a bug; if sdcc knows it has a constant value, the assignment itself may be optimized away and any references to x would be replaced with the constant. ---------------------------------------------------------------------- Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:42 Message: > x = x & !DIGIT_LEFTCOMMA_MASK; Beware: !0x20 == 0. You want ~0x20 = 0xffdf. I will investigate your additional comments later, but this should help you get on. Hope that helps, Raphael ---------------------------------------------------------------------- Comment By: Lisandro Pin () Date: 2012-04-30 00:17 Message: Sorry, the second code snippet should read: unsigned char x = digit[currentDigit]; x = x & !DIGIT_LEFTCOMMA_MASK; ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |
From: SourceForge.net <no...@so...> - 2012-04-30 16:45:28
|
Bugs item #3522502, was opened at 2012-04-30 00:15 Message generated for change (Comment added) made by You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: pic14 target Group: non bugs Status: Closed Resolution: Invalid Priority: 5 Private: No Submitted By: Lisandro Pin () Assigned to: Raphael Neider (tecodev) Summary: Bitwise and fails for negated constants on pic14 (16F877A) Initial Comment: Trying to disable a bit using a bitwise and and a negated mask fails if the mask is a defined constant. This is on SDCC #7066 3.1.0 compiling for a PIC16F877A (pic14); for example: #include <pic16f877a.h> #include <stdint.h> #define DIGIT_LEFTCOMMA_MASK 0x20 [...] unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; [...] ...generates the following code: ; .line 219; "nixie_clock.c" unsigned char x = digit[currentDigit]; BANKSEL r0x1035 MOVF r0x1035,W MOVWF r0x1036 ; .line 220; "nixie_clock.c" x = x & DIGIT_LEFTCOMMA_MASK; MOVLW 0x20 ANDWF r0x1036,F Negating the constant in the expression at line 220 should blank a single bit on x: unsigned char x = digit[currentDigit]; x = x & DIGIT_LEFTCOMMA_MASK; ..but instead of that *no* code is generated for this snippet X is declared but left completely uninitialized . in fact, it doesn't even gets assigned the value on digit[currentDigit]. This is the simplest example i could work out which showcases this bug. It doesn't seems to be a syntax parser bug either; enclosing the defined constant in parenthesis or restyiling it (1 << 5, 0b00100000) makes no difference. ---------------------------------------------------------------------- Comment By: Lisandro Pin () Date: 2012-04-30 09:45 Message: Indeed :( This is a stupid non-bug, sorry. The neg operator is what i wanted here. The optimizer is doing its job just fine then, since with my (current) code that particular variable is always zero. My apologies. ---------------------------------------------------------------------- Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:55 Message: I just confirmed that int do_neg(int v) { int x = v; x = x & OP 0x20; /* OP = ! or ~ */ return x; } compiles properly in both cases (return 0; or return v&0xffdf;), so I close this. ---------------------------------------------------------------------- Comment By: Erik Petrich (epetrich) Date: 2012-04-30 00:45 Message: I think you should be using the compliment operator instead: unsigned char x = digit[currentDigit]; x = x & ~DIGIT_LEFTCOMMA_MASK; The ! operator is a boolean operator; it considers whether its operand as a whole is zero or non-zero. Since 0x20 is a non-zero value, the result of !0x20 equal 0. Thus x will always end up with the value 0. That x was not assigned is not necessarily a bug; if sdcc knows it has a constant value, the assignment itself may be optimized away and any references to x would be replaced with the constant. ---------------------------------------------------------------------- Comment By: Raphael Neider (tecodev) Date: 2012-04-30 00:42 Message: > x = x & !DIGIT_LEFTCOMMA_MASK; Beware: !0x20 == 0. You want ~0x20 = 0xffdf. I will investigate your additional comments later, but this should help you get on. Hope that helps, Raphael ---------------------------------------------------------------------- Comment By: Lisandro Pin () Date: 2012-04-30 00:17 Message: Sorry, the second code snippet should read: unsigned char x = digit[currentDigit]; x = x & !DIGIT_LEFTCOMMA_MASK; ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=100599&aid=3522502&group_id=599 |