ARM: jump label support

Before replacing an instruction, the ftrace code determines what the old instruction should be and verifies that that's what's really there in memory before replacing it. This is useful if for example a bug in mcountrecord causes it to record wrong locations.

However, in cases where we replace call sites in entry-common.S, these checks are not needed. For these, we currently just memcpy() the memory content and then "verify" it -- this is quite useless and can be removed.

Signed-off-by Rabin Vincent <[email protected]>

---
 arch/arm/kernel/ftrace.c |   18 +++++++++---------
 1 files changed, 9 insertions(+), 9 deletions(-)

arch/arm/kernel/ftrace.c +0 -0

index c0062ad..e9488ad 100644

Quoted 8 lines · Rabin Vincent

arch/arm/kernel/ftrace.c +0 -0

index c0062ad..e9488ad 100644
@@ -125,11 +125,13 @@ static int ftrace_modify_code(unsigned long pc, unsigned long old,
 {
 	unsigned long replaced;
 

arch/arm/kernel/ftrace.c static int ftrace_modify_code(unsigned long pc, unsigned long old, · line 128

Quoted 3 lines

arch/arm/kernel/ftrace.c +1 -2

-	if (probe_kernel_read(&replaced, (void *)pc, MCOUNT_INSN_SIZE))
-		return -EFAULT;
+	if (old) {

So, we're using the instruction value '0' to mean that we don't want to check? Wouldn'it it be better to pass a flag in to indicate this instead of creating a magic value?

From 18ad9e696a3b3986babb1c91807d3f39d6468176 Mon Sep 17 00:00:00 2001

Quoted 9 lines · Russell King - ARM Linux

Quoted 8 lines · Rabin Vincent

arch/arm/kernel/ftrace.c +0 -0

index c0062ad..e9488ad 100644
@@ -125,11 +125,13 @@ static int ftrace_modify_code(unsigned long pc, unsigned long old,
 {
 	unsigned long replaced;
 

Quoted 7 lines

arch/arm/kernel/ftrace.c static int ftrace_modify_code(unsigned long pc, unsigned long old, · line 128

Quoted 3 lines

arch/arm/kernel/ftrace.c +1 -2

-	if (probe_kernel_read(&replaced, (void *)pc, MCOUNT_INSN_SIZE))
-		return -EFAULT;
+	if (old) {

So, we're using the instruction value '0' to mean that we don't want to check? Wouldn'it it be better to pass a flag in to indicate this instead of creating a magic value?

OK. I think you applied this patch as-is anyway, so here is a follow-on patch:

Quoted 18 lines · Rabin Vincent

Quoted 16 lines · Russell King - ARM Linux

arch/arm/kernel/ftrace.c static int ftrace_modify_code(unsigned long pc, unsigned long old, · line 128

Quoted 11 lines · Rabin Vincent

arch/arm/kernel/ftrace.c +1 -2

index c0062ad..e9488ad 100644
@@ -125,11 +125,13 @@ static int ftrace_modify_code(unsigned long pc, unsigned long old,
 {
 	unsigned long replaced;
 
-	if (probe_kernel_read(&replaced, (void *)pc, MCOUNT_INSN_SIZE))
-		return -EFAULT;
+	if (old) {

So, we're using the instruction value '0' to mean that we don't want to check? Wouldn'it it be better to pass a flag in to indicate this instead of creating a magic value?

Quoted 2 lines

OK. I think you applied this patch as-is anyway, so here is a follow-on patch:

I'd still much prefer it to be part of the original patch. I can replace the patch I've merged or augment it with another patch - whichever way you prefer.

From 11a4aea10f1b2d56c70c34def29b3f8d56b88dd5 Mon Sep 17 00:00:00 2001

Replacing the original is OK with me, new patch below. Note that "ARM:
ftrace: use canonical Thumb-2 wide instruction format" will need to be manually rebased on top of it since there is a change in the context.

As commit 592201a9f15 (ARM: Thumb-2: Support Thumb-2 in undefined instruction handler) says:

32-bit Thumb instructions are specified in the form:
((first_half << 16 ) | second_half)
which matches the layout used by the ARM ARM.

Convert the ftrace code to use the same format to avoid the usage of different formats in kernel code.

Signed-off-by Rabin Vincent <[email protected]>

---
 arch/arm/kernel/ftrace.c |   13 +++++++++++--
 1 files changed, 11 insertions(+), 2 deletions(-)

arch/arm/kernel/ftrace.c +11 -2

index e9488ad..72a381a 100644
@@ -16,10 +16,11 @@
 #include <linux/uaccess.h>
 
 #include <asm/cacheflush.h>
+#include <asm/opcodes.h>
 #include <asm/ftrace.h>
 
 #ifdef CONFIG_THUMB2_KERNEL
-#define	NOP		0xeb04f85d	/* pop.w {lr} */
+#define	NOP		0xf85deb04	/* pop.w {lr} */
 #else
 #define	NOP		0xe8bd4000	/* pop {lr} */
 #endif

@@ -88,7 +89,7 @@ static unsigned long ftrace_gen_branch(unsigned long pc, unsigned long addr,
 	if (link)
 		second |= 1 << 14;
 
-	return (second << 16) | first;
+	return __opcode_thumb32_compose(first, second);
 }
 #else
 static unsigned long ftrace_gen_branch(unsigned long pc, unsigned long addr,

@@ -125,6 +126,14 @@ static int ftrace_modify_code(unsigned long pc, unsigned long old,
 {
 	unsigned long replaced;
 
+	if (IS_ENABLED(CONFIG_THUMB2_KERNEL)) {
+		old = __opcode_to_mem_thumb32(old);
+		new = __opcode_to_mem_thumb32(new);
+	} else {
+		old = __opcode_to_mem_arm(old);
+		new = __opcode_to_mem_arm(new);
+	}
+
 	if (old) {
 		if (probe_kernel_read(&replaced, (void *)pc, MCOUNT_INSN_SIZE))
 			return -EFAULT;

Signature · 7 lines

1.7.8.3


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

Extract out the code patching code from kprobes so that it can be used from the jump label code. Additionally, the separated code:

- Uses the IS_ENABLED() macros instead of the #ifdefs for THUMB2 support

- Unifies the two separate functions in kprobes, providing one function that uses stop_machine() internally, and one that can be called from stop_machine() directly

- Patches the text on all CPUs only on processors requiring software broadcasting of cache operations

Cc Jon Medhurst <[email protected]>

Signed-off-by Rabin Vincent <[email protected]>

---
 arch/arm/kernel/Makefile  |    3 +-
 arch/arm/kernel/kprobes.c |   86 ++++++++++++--------------------------------
 arch/arm/kernel/patch.c   |   73 ++++++++++++++++++++++++++++++++++++++
 arch/arm/kernel/patch.h   |    7 ++++
 4 files changed, 106 insertions(+), 63 deletions(-)
 create mode 100644 arch/arm/kernel/patch.c
 create mode 100644 arch/arm/kernel/patch.h

arch/arm/kernel/patch.c new file +0 -0

new file mode 100644
index 0000000..30eff23
@@ -0,0 +1,73 @@

arch/arm/kernel/patch.c new file +5 -0

+
+		size = sizeof(u32);
+	} else {
+		if (thumb2)
+			insn = __opcode_to_mem_thumb32(insn);

Extract out the code patching code from kprobes so that it can be used from the jump label code. Additionally, the separated code:

- Uses the IS_ENABLED() macros instead of the #ifdefs for THUMB2 support

- Unifies the two separate functions in kprobes, providing one function that uses stop_machine() internally, and one that can be called from stop_machine() directly

- Patches the text on all CPUs only on processors requiring software broadcasting of cache operations

Cc Jon Medhurst <[email protected]>

Signed-off-by Rabin Vincent <[email protected]>

---
 arch/arm/kernel/Makefile  |    3 +-
 arch/arm/kernel/kprobes.c |   86 ++++++++++++--------------------------------
 arch/arm/kernel/patch.c   |   73 ++++++++++++++++++++++++++++++++++++++
 arch/arm/kernel/patch.h   |    7 ++++
 4 files changed, 106 insertions(+), 63 deletions(-)
 create mode 100644 arch/arm/kernel/patch.c
 create mode 100644 arch/arm/kernel/patch.h

arch/arm/kernel/Makefile +2 -1

index dd3d5f1..8c63ee8 100644
@@ -8,6 +8,7 @@ AFLAGS_head.o        := -DTEXT_OFFSET=$(TEXT_OFFSET)
 ifdef CONFIG_FUNCTION_TRACER
 CFLAGS_REMOVE_ftrace.o = -pg
 CFLAGS_REMOVE_insn.o = -pg
+CFLAGS_REMOVE_patch.o = -pg
 endif
 
 CFLAGS_REMOVE_return_address.o = -pg

@@ -38,7 +39,7 @@ obj-$(CONFIG_HAVE_ARM_TWD)	+= smp_twd.o
 obj-$(CONFIG_DYNAMIC_FTRACE)	+= ftrace.o insn.o
 obj-$(CONFIG_FUNCTION_GRAPH_TRACER)	+= ftrace.o insn.o
 obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o
-obj-$(CONFIG_KPROBES)		+= kprobes.o kprobes-common.o
+obj-$(CONFIG_KPROBES)		+= kprobes.o kprobes-common.o patch.o
 ifdef CONFIG_THUMB2_KERNEL
 obj-$(CONFIG_KPROBES)		+= kprobes-thumb.o
 else

arch/arm/kernel/kprobes.c +24 -62

index 129c116..ab1869d 100644
@@ -29,6 +29,7 @@
 #include <asm/cacheflush.h>
 
 #include "kprobes.h"
+#include "patch.h"
 
 #define MIN_STACK_SIZE(addr) 				\
 	min((unsigned long)MAX_STACK_SIZE,		\

@@ -103,57 +104,33 @@ int __kprobes arch_prepare_kprobe(struct kprobe *p)
 	return 0;
 }
 
-#ifdef CONFIG_THUMB2_KERNEL
-
-/*
- * For a 32-bit Thumb breakpoint spanning two memory words we need to take
- * special precautions to insert the breakpoint atomically, especially on SMP
- * systems. This is achieved by calling this arming function using stop_machine.
- */
-static int __kprobes set_t32_breakpoint(void *addr)
-{
-	((u16 *)addr)[0] = KPROBE_THUMB32_BREAKPOINT_INSTRUCTION >> 16;
-	((u16 *)addr)[1] = KPROBE_THUMB32_BREAKPOINT_INSTRUCTION & 0xffff;
-	flush_insns(addr, 2*sizeof(u16));
-	return 0;
-}
-
 void __kprobes arch_arm_kprobe(struct kprobe *p)
 {
-	uintptr_t addr = (uintptr_t)p->addr & ~1; /* Remove any Thumb flag */
-
-	if (!is_wide_instruction(p->opcode)) {
-		*(u16 *)addr = KPROBE_THUMB16_BREAKPOINT_INSTRUCTION;
-		flush_insns(addr, sizeof(u16));
-	} else if (addr & 2) {
-		/* A 32-bit instruction spanning two words needs special care */
-		stop_machine(set_t32_breakpoint, (void *)addr, &cpu_online_map);
+	unsigned int brkp;
+	void *addr;
+
+	if (IS_ENABLED(CONFIG_THUMB2_KERNEL)) {
+		/* Remove any Thumb flag */
+		addr = (void *)((uintptr_t)p->addr & ~1);
+
+		if (is_wide_instruction(p->opcode))
+			brkp = KPROBE_THUMB32_BREAKPOINT_INSTRUCTION;
+		else
+			brkp = KPROBE_THUMB16_BREAKPOINT_INSTRUCTION;
 	} else {
-		/* Word aligned 32-bit instruction can be written atomically */
-		u32 bkp = KPROBE_THUMB32_BREAKPOINT_INSTRUCTION;
-#ifndef __ARMEB__ /* Swap halfwords for little-endian */
-		bkp = (bkp >> 16) | (bkp << 16);
-#endif
-		*(u32 *)addr = bkp;
-		flush_insns(addr, sizeof(u32));
-	}
-}
+		kprobe_opcode_t insn = p->opcode;
 
-#else /* !CONFIG_THUMB2_KERNEL */
+		addr = p->addr;
+		brkp = KPROBE_ARM_BREAKPOINT_INSTRUCTION;
 
-void __kprobes arch_arm_kprobe(struct kprobe *p)
-{
-	kprobe_opcode_t insn = p->opcode;
-	kprobe_opcode_t brkp = KPROBE_ARM_BREAKPOINT_INSTRUCTION;
-	if (insn >= 0xe0000000)
-		brkp |= 0xe0000000;  /* Unconditional instruction */
-	else
-		brkp |= insn & 0xf0000000;  /* Copy condition from insn */
-	*p->addr = brkp;
-	flush_insns(p->addr, sizeof(p->addr[0]));
-}
+		if (insn >= 0xe0000000)
+			brkp |= 0xe0000000;  /* Unconditional instruction */
+		else
+			brkp |= insn & 0xf0000000;  /* Copy condition from insn */
+	}
 
-#endif /* !CONFIG_THUMB2_KERNEL */
+	patch_text(addr, brkp);
+}
 
 /*
  * The actual disarming is done here on each CPU and synchronized using

@@ -166,25 +143,10 @@ void __kprobes arch_arm_kprobe(struct kprobe *p)
 int __kprobes __arch_disarm_kprobe(void *p)
 {
 	struct kprobe *kp = p;
-#ifdef CONFIG_THUMB2_KERNEL
-	u16 *addr = (u16 *)((uintptr_t)kp->addr & ~1);
-	kprobe_opcode_t insn = kp->opcode;
-	unsigned int len;
+	void *addr = (void *)((uintptr_t)kp->addr & ~1);
 
-	if (is_wide_instruction(insn)) {
-		((u16 *)addr)[0] = insn>>16;
-		((u16 *)addr)[1] = insn;
-		len = 2*sizeof(u16);
-	} else {
-		((u16 *)addr)[0] = insn;
-		len = sizeof(u16);
-	}
-	flush_insns(addr, len);
+	__patch_text(addr, kp->opcode);
 
-#else /* !CONFIG_THUMB2_KERNEL */
-	*kp->addr = kp->opcode;
-	flush_insns(kp->addr, sizeof(kp->addr[0]));
-#endif
 	return 0;
 }
 

arch/arm/kernel/patch.c new file +73 -0

new file mode 100644
index 0000000..30eff23
@@ -0,0 +1,73 @@
+#include <linux/kernel.h>
+#include <linux/kprobes.h>
+#include <linux/stop_machine.h>
+
+#include <asm/cacheflush.h>
+#include <asm/smp_plat.h>
+#include <asm/opcodes.h>
+
+#include "patch.h"
+
+struct patch {
+	void *addr;
+	unsigned int insn;
+};
+
+void __kprobes __patch_text(void *addr, unsigned int insn)
+{
+	bool thumb2 = IS_ENABLED(CONFIG_THUMB2_KERNEL);
+	int size;
+
+	if (thumb2 && __opcode_is_thumb16(insn)) {
+		*(u16 *)addr = __opcode_to_mem_thumb16(insn);
+		size = sizeof(u16);
+	} else if (thumb2 && ((uintptr_t)addr & 2)) {
+		u16 *addrh = addr;
+
+		addrh[0] = __opcode_thumb32_first(insn);
+		addrh[1] = __opcode_thumb32_second(insn);
+
+		size = sizeof(u32);
+	} else {
+		if (thumb2)
+			insn = __opcode_to_mem_thumb32(insn);
+		else
+			insn = __opcode_to_mem_arm(insn);
+
+		*(u32 *)addr = insn;
+		size = sizeof(u32);
+	}
+
+	flush_icache_range((uintptr_t)(addr),
+			   (uintptr_t)(addr) + size);
+}
+
+static int __kprobes patch_text_stop_machine(void *data)
+{
+	struct patch *patch = data;
+
+	__patch_text(patch->addr, patch->insn);
+
+	return 0;
+}
+
+void __kprobes patch_text(void *addr, unsigned int insn)
+{
+	struct patch patch = {
+		.addr = addr,
+		.insn = insn,
+	};
+
+	if (cache_ops_need_broadcast()) {
+		stop_machine(patch_text_stop_machine, &patch, cpu_online_mask);
+	} else {
+		bool straddles_word = IS_ENABLED(CONFIG_THUMB2_KERNEL)
+				      && __opcode_is_thumb32(insn)
+				      && ((uintptr_t)addr & 2);
+
+		if (straddles_word)
+			stop_machine(patch_text_stop_machine, &patch, NULL);
+		else
+			__patch_text(addr, insn);
+	}
+}

arch/arm/kernel/patch.h new file +7 -0

new file mode 100644
index 0000000..b4731f2
@@ -0,0 +1,7 @@
+#ifndef _ARM_KERNEL_PATCH_H
+#define _ARM_KERNEL_PATCH_H
+
+void patch_text(void *addr, unsigned int insn);
+void __patch_text(void *addr, unsigned int insn);
+
+#endif

Some versions of ARM GCC which do support asm goto, have problems handling the the %c specifier. ?Since we need the %c to support jump labels on ARM, detect that too in the asm goto detection script to avoid build errors with these versions.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48637

Cc Jason Baron <[email protected]>

Cc linux-kernel at vger.kernel.org

Signed-off-by Rabin Vincent <[email protected]>

---
?scripts/gcc-goto.sh | ? 18 +++++++++++++++++- ?1 files changed, 17 insertions(+), 1 deletions(-)

scripts/gcc-goto.sh +0 -0

index 98cffcb..9b744de 100644
@@ -2,4 +2,20 @@

?# Test for gcc 'asm goto' support
?# Copyright (C) 2010, Jason Baron <[email protected]>

scripts/gcc-goto.sh +17 -2

-echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"
+cat << "END" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"
+int main(void)
+{
+#ifdef __arm__
+ ? ? ? /*
+ ? ? ? ?* Not related to asm goto, but used by jump label
+ ? ? ? ?* and broken on some ARM GCC versions (see GCC Bug 48637).
+ ? ? ? ?*/
+ ? ? ? static struct { int dummy; int state; } tp;
+ ? ? ? asm ("@ %c0" :: "i" (&tp.state));
+#endif
+
+entry:
+ ? ? ? asm goto ("" :::: entry);
+ ? ? ? return 0;
+}
+END
--

1.7.8.3

Jason,

Quoted 10 lines · Rabin Vincent

Some versions of ARM GCC which do support asm goto, have problems handling the the %c specifier. ?Since we need the %c to support jump labels on ARM, detect that too in the asm goto detection script to avoid build errors with these versions.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48637

Cc Jason Baron <[email protected]>

Cc linux-kernel at vger.kernel.org

Signed-off-by Rabin Vincent <[email protected]>

Could you please ack this patch if it's OK for you? Then I could try to send it via rmk's ARM patch system along with the rest of the series.

Thanks.

Quoted 25 lines

---
?scripts/gcc-goto.sh | ? 18 +++++++++++++++++- ?1 files changed, 17 insertions(+), 1 deletions(-)

scripts/gcc-goto.sh +0 -0

index 98cffcb..9b744de 100644
@@ -2,4 +2,20 @@

?# Test for gcc 'asm goto' support
?# Copyright (C) 2010, Jason Baron <[email protected]>

scripts/gcc-goto.sh +12 -1

-echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"
+cat << "END" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"
+int main(void)
+{
+#ifdef __arm__
+ ? ? ? /*
+ ? ? ? ?* Not related to asm goto, but used by jump label
+ ? ? ? ?* and broken on some ARM GCC versions (see GCC Bug 48637).
+ ? ? ? ?*/
+ ? ? ? static struct { int dummy; int state; } tp;
+ ? ? ? asm ("@ %c0" :: "i" (&tp.state));
+#endif
+

Quoted 8 lines

scripts/gcc-goto.sh +5 -1

+entry:
+ ? ? ? asm goto ("" :::: entry);
+ ? ? ? return 0;
+}
+END
--

1.7.8.3

Some versions of ARM GCC which do support asm goto, have problems handling the the %c specifier. Since we need the %c to support jump labels on ARM, detect that too in the asm goto detection script to avoid build errors with these versions.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48637

Cc Jason Baron <[email protected]>

Cc linux-kernel at vger.kernel.org

Signed-off-by Rabin Vincent <[email protected]>

---
 scripts/gcc-goto.sh |   18 +++++++++++++++++-
 1 files changed, 17 insertions(+), 1 deletions(-)

scripts/gcc-goto.sh +0 -1

index 98cffcb..9b744de 100644
@@ -2,4 +2,20 @@
 # Test for gcc 'asm goto' support
 # Copyright (C) 2010, Jason Baron <[email protected]>
 
-echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"

Quoted 4 lines · Rabin Vincent

Some versions of ARM GCC which do support asm goto, have problems handling the the %c specifier. Since we need the %c to support jump labels on ARM, detect that too in the asm goto detection script to avoid build errors with these versions.

I'm not sure how this detects properly working %c support. %c support has been rather flakey on ARM for some time, I'm not sure which version of gcc was fixed for it.

Quoted 19 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48637

Cc Jason Baron <[email protected]>

Cc linux-kernel at vger.kernel.org

Signed-off-by Rabin Vincent <[email protected]>

---
 scripts/gcc-goto.sh |   18 +++++++++++++++++-
 1 files changed, 17 insertions(+), 1 deletions(-)

scripts/gcc-goto.sh +0 -1

index 98cffcb..9b744de 100644
@@ -2,4 +2,20 @@
 # Test for gcc 'asm goto' support
 # Copyright (C) 2010, Jason Baron <[email protected]>
 
-echo "int main(void) { entry: asm goto (\"\"::::entry); return 0; }" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"

scripts/gcc-goto.sh line 14

Quoted 10 lines

scripts/gcc-goto.sh +10 -0

+cat << "END" | $@ -x c - -c -o /dev/null >/dev/null 2>&1 && echo "y"
+int main(void)
+{
+#ifdef __arm__
+	/*
+	 * Not related to asm goto, but used by jump label
+	 * and broken on some ARM GCC versions (see GCC Bug 48637).
+	 */
+	static struct { int dummy; int state; } tp;
+	asm ("@ %c0" :: "i" (&tp.state));

While this detects the presence of the ICE, previous compilers included the '#' before the constant, which leads to problems. I think a better check would be:

	asm(".long %c0" :: "i" (&tp.state));

to make sure that it spits out something purely numeric, rather than something prefixed with a '#'.

From f3a3bd64f72720def5cfbaedf6ff83ca54f1644b Mon Sep 17 00:00:00 2001

Add the arch-specific code to support jump labels for ARM and Thumb-2.

This code will only be activated on compilers that are capable of building it. It has been tested with GCC 4.6 patched with the patch from GCC bug 48637.

Cc Jason Baron <[email protected]>

Signed-off-by Rabin Vincent <[email protected]>

---

+static __always_inline bool arch_static_branch(struct jump_label_key *key)

Quoted 9 lines · Rabin Vincent

Add the arch-specific code to support jump labels for ARM and Thumb-2.

This code will only be activated on compilers that are capable of building it. It has been tested with GCC 4.6 patched with the patch from GCC bug 48637.

Cc Jason Baron <[email protected]>

Signed-off-by Rabin Vincent <[email protected]>

---

...

Quoted 1 line

+static __always_inline bool arch_static_branch(struct jump_label_key *key)

Hmm, there's now a patch in linux-next ("static keys: Introduce 'struct static_key', static_key_true()/false() and static_key_slow_[inc|dec]()") via the -tip tree which would cause this not to build anymore since struct jump_label_key was renamed to struct static_key.

I'm not sure how this could be handled to keep this compiling both in the arm tree separately and in linux-next. I guess the easiest is to delay this until the next cycle, since it's not applied yet.

v2:
- Use helper macros from Dave Martin's "ARM: Add generic instruction opcode manipulation helpers"
http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=7278/1

Quoted 4 lines · Rabin Vincent

v2:
- Use helper macros from Dave Martin's "ARM: Add generic instruction opcode manipulation helpers"
http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=7278/1

This patch is broken, it contains two diff listings for arch/arm/include/asm/opcodes.h

The second one looks more correct as the diff accounts for commit 0c9030deaf59d444 (ARM: 7206/1: Add generic ARM instruction set condition code checks). However, when opcodes.h is included in assembler files it produces error as it #includes C headers.