Skip to contentSkip to conversation

Orion NAND: Make dword load asm volatile to avoid GCC optimizing it away

PATCH In review Simon Kagstrom 2 participants 7 messages Jul 14, 2009 – Aug 21, 2009

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Orion NAND: Make dword load asm volatile to avoid GCC optimizing it away

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch makes the inline assembly volatile to avoid this situation.

---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +1 -1
index 7ad9722..3f9b113 100644
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
 		buf64[i++] = x;
 	}
 	i *= 8;
Signature · 1 line
1.6.0.4
#1 lore raw
Quoted 3 lines · Simon Kagstrom

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch makes the inline assembly volatile to avoid this situation.

If GCC does optimize away this inline asm then this is a serious GCC bug. The inline asm uses an output operand for which a dependency exists on the very next line.

If I were you I'd try to find a non broken GCC version instead.

Quoted 26 lines
---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +1 -1
index 7ad9722..3f9b113 100644
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
 		buf64[i++] = x;
 	}
 	i *= 8;
Signature · 6 lines
1.6.0.4


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
#2 lore raw
Quoted 9 lines · On Tue, 14 Jul 2009 12:40:33 -0400 (EDT) Nicolas Pitre <[email protected]> wrote:
Quoted 3 lines · Simon Kagstrom

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch makes the inline assembly volatile to avoid this situation.

If GCC does optimize away this inline asm then this is a serious GCC bug. The inline asm uses an output operand for which a dependency exists on the very next line.

I've been away on vacation, sorry for not replying until now.

Anyway, I spoke to the GCC people at gcc-help, and they insist that the inlined assembly is wrong. The problem is that GCC doesn't infer from the instruction that it accesses memory, and it can thereby move it out of the loop.

So here comes an updated patch.

// Simon
--
Orion NAND: Clobber memory to make sure that GCC does not move ldrd

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch clobbers memory, and makes the instruction volatile to avoid the issue. I've discussed this at gcc-help, refer to the thread at

http://gcc.gnu.org/ml/gcc-help/2009-08/msg00187.html

---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +1 -1
index 7ad9722..845f9a9 100644
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base) : "memory");
 		buf64[i++] = x;
 	}
 	i *= 8;
Signature · 1 line
1.6.0.4
#3 lore raw
Quoted 13 lines · Simon Kagstrom
Quoted 9 lines · On Tue, 14 Jul 2009 12:40:33 -0400 (EDT) Nicolas Pitre <[email protected]> wrote:
Quoted 3 lines · Simon Kagstrom

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch makes the inline assembly volatile to avoid this situation.

If GCC does optimize away this inline asm then this is a serious GCC bug. The inline asm uses an output operand for which a dependency exists on the very next line.

Quoted 6 lines

I've been away on vacation, sorry for not replying until now.

Anyway, I spoke to the GCC people at gcc-help, and they insist that the inlined assembly is wrong. The problem is that GCC doesn't infer from the instruction that it accesses memory, and it can thereby move it out of the loop.

Oh! OK. That's different though. In your initial report you said that the inline asm was _removed_. I can understand why it might be factored out of the loop though, but it cannot be removed entirely.

Quoted 23 lines

So here comes an updated patch.

// Simon
--
Orion NAND: Clobber memory to make sure that GCC does not move ldrd

GCC 4.3.3 happily removes the dword load instruction in orion_nand_read_buf. This patch clobbers memory, and makes the instruction volatile to avoid the issue. I've discussed this at gcc-help, refer to the thread at

http://gcc.gnu.org/ml/gcc-help/2009-08/msg00187.html

---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +0 -0
index 7ad9722..845f9a9 100644

drivers/mtd/nand/orion_nand.c static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) · line 64

Quoted 5 lines
drivers/mtd/nand/orion_nand.c +1 -1
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base) : "memory");

I think that the early clobber buys you nothing, and the memory clobber is way overkill here. The volatile ought to be all that is needed. Can you confirm that only the addition of volatile makes the code OK? My gcc version is 4.3.2 and that makes no difference what so ever as the code as is produces the correct result already in my case.

Nicolas

#4 lore raw
Quoted 8 lines · On Wed, 19 Aug 2009 10:47:14 -0400 (EDT) Nicolas Pitre <[email protected]> wrote:
Quoted 4 lines

Anyway, I spoke to the GCC people at gcc-help, and they insist that the inlined assembly is wrong. The problem is that GCC doesn't infer from the instruction that it accesses memory, and it can thereby move it out of the loop.

Oh! OK. That's different though. In your initial report you said that the inline asm was _removed_. I can understand why it might be factored out of the loop though, but it cannot be removed entirely.

Sorry, I'll be careful about wording in the future :-)

Quoted 8 lines

Review

Quoted 2 lines
(quoted diff) +1 -1
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base) : "memory");

I think that the early clobber buys you nothing, and the memory clobber is way overkill here. The volatile ought to be all that is needed. Can you confirm that only the addition of volatile makes the code OK? My gcc version is 4.3.2 and that makes no difference what so ever as the code as is produces the correct result already in my case.

Yes, it works fine with 4.3.3 and 4.4.1 with this change. So the updated patch can be found below. I belive the early clobber should be there though, since (from the ARM architecture reference manual):

If <addressing_mode> performs base register write-back and the base register <Rn> is one of the two destination registers of the instruction, the results are UNPREDICTABLE.

it works fine without the early clobber as well, but I'd feel more safe having it in.

// Simon
--
Orion NAND: Make asm volatile avoid GCC pushing ldrd out of the loop

GCC 4.3.3 and 4.4.1 happily moves the dword load instruction out of the loop in orion_nand_read_buf. This patch makes the instruction volatile to avoid the issue. I've discussed this at gcc-help, refer to the thread at

http://gcc.gnu.org/ml/gcc-help/2009-08/msg00187.html

The early clobber is added to avoid the destination registers and the source register overlapping.

---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +1 -1
index 7ad9722..0d9d4bc 100644
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base));
 		buf64[i++] = x;
 	}
 	i *= 8;
Signature · 1 line
1.6.0.4
Acked-by
#5 lore raw
Quoted 13 lines · Simon Kagstrom
Quoted 5 lines · On Wed, 19 Aug 2009 10:47:14 -0400 (EDT) Nicolas Pitre <[email protected]> wrote:

I think that the early clobber buys you nothing, and the memory clobber is way overkill here. The volatile ought to be all that is needed. Can you confirm that only the addition of volatile makes the code OK? My gcc version is 4.3.2 and that makes no difference what so ever as the code as is produces the correct result already in my case.

Yes, it works fine with 4.3.3 and 4.4.1 with this change. So the updated patch can be found below. I belive the early clobber should be there though, since (from the ARM architecture reference manual):

Quoted 6 lines

If <addressing_mode> performs base register write-back and the base register <Rn> is one of the two destination registers of the instruction, the results are UNPREDICTABLE.

it works fine without the early clobber as well, but I'd feel more safe having it in.

But this isn't the case here. We don't perform any writeback. You get a writeback when you have an addressing mode of the form:

	insn	rd, [rn, rm]!
	insn	rd, [rn, #off]!
	insn	rd, [rn], #off

but not with:

	insn	rd, [rn, #off]

Etc.

Still the early clobber shouldn't have any adverse effect either, unlike the memory clobber.

Unless the MTD guys are going to pick this patch and push it to Linus soon I'll carry it in the Orion git repo.

Quoted 36 lines

// Simon
--
Orion NAND: Make asm volatile avoid GCC pushing ldrd out of the loop

GCC 4.3.3 and 4.4.1 happily moves the dword load instruction out of the loop in orion_nand_read_buf. This patch makes the instruction volatile to avoid the issue. I've discussed this at gcc-help, refer to the thread at

http://gcc.gnu.org/ml/gcc-help/2009-08/msg00187.html

The early clobber is added to avoid the destination registers and the source register overlapping.

---
 drivers/mtd/nand/orion_nand.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/mtd/nand/orion_nand.c +1 -1
index 7ad9722..0d9d4bc 100644
@@ -61,7 +61,7 @@ static void orion_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 	buf64 = (uint64_t *)buf;
 	while (i < len/8) {
 		uint64_t x;
-		asm ("ldrd\t%0, [%1]" : "=r" (x) : "r" (io_base));
+		asm volatile ("ldrd\t%0, [%1]" : "=&r" (x) : "r" (io_base));
 		buf64[i++] = x;
 	}
 	i *= 8;
Signature · 1 line
1.6.0.4
#6 lore raw
Quoted 14 lines · On Thu, 20 Aug 2009 12:14:47 -0400 (EDT) Nicolas Pitre <[email protected]> wrote:
Quoted 10 lines

Yes, it works fine with 4.3.3 and 4.4.1 with this change. So the updated patch can be found below. I belive the early clobber should be there though, since (from the ARM architecture reference manual):

If <addressing_mode> performs base register write-back and the base register <Rn> is one of the two destination registers of the instruction, the results are UNPREDICTABLE.

it works fine without the early clobber as well, but I'd feel more safe having it in.

But this isn't the case here. We don't perform any writeback. You get a writeback when you have an addressing mode of the form:

Quoted 7 lines
	insn	rd, [rn, rm]!
	insn	rd, [rn, #off]!
	insn	rd, [rn], #off

but not with:

	insn	rd, [rn, #off]

OK, I'm still a beginner on the ARM architecture, so thanks for the explanation!

Quoted 7 lines

Still the early clobber shouldn't have any adverse effect either, unlike the memory clobber.

Unless the MTD guys are going to pick this patch and push it to Linus soon I'll carry it in the Orion git repo.

Great, thanks!

// Simon