Start incorporating the ARM integrated assembler.

src/IceTargetLowering.h

Index: src/IceTargetLowering.h
diff --git a/src/IceTargetLowering.h b/src/IceTargetLowering.h
index f35983f1846e6bf9ed43ff05a238bb470cbfd241..e8c2ab8301225c869211baa3feee6727c1690bc4 100644
--- a/src/IceTargetLowering.h
+++ b/src/IceTargetLowering.h
@@ -28,6 +28,18 @@
 
 namespace Ice {
 
+// UnimplementedError is defined as a macro so that we can get actual line
+// numbers.
+#define UnimplementedError(Flags)                                              \
+  do {                                                                         \
+    if (!static_cast<const ClFlags &>(Flags).getSkipUnimplemented()) {         \

[Jim Stichnoth, 2015/10/08 23:50:41]

Do you really need the cast here?

For proper macro safety, you should probably use ((Flags)), though I guess only
one level of parentheses is needed if you drop the cast.

[John, 2015/10/09 12:12:24]

I'll reply on his behalf, for this is my fault.

Regarding the cast, no you don't need it, but it prevents that the macro is used
with anything that exports a getSkipUnimplemented() method. Think "poor man's
type safety."

Regarding the parenthesis, I think

static_cast<>(Flags)

and

static_cast<>((Flags))

are the same. You just wrap macro parameters to prevent associativity issues,
e.g.,

#define TIMES_10(s) (s * 10)

cout << TIMES_10(a + b)  // oops, this is cout << (a + b * 10);

Given that the cast already includes the parenthesis, this should be fine.

[Karl, 2015/10/09 19:08:18]

Acknowledged.

[Jim Stichnoth, 2015/10/09 20:05:44]

I guess I was thinking of the case where the "Flags" macro arg is instantiated
as "A,B" and then substitution makes it parse as two function arguments instead
of a comma expression.  However, I guess you can't really even pass in a comma
in a macro arg unless the whole arg is inside parentheses, so I guess my
argument is moot.

+      /* Use llvm_unreachable instead of report_fatal_error, which gives       \
+         better stack traces. */                                               \
+      llvm_unreachable("Not yet implemented");                                 \
+      abort();                                                                 \
+    }                                                                          \
+  } while (0)
+
 /// LoweringContext makes it easy to iterate through non-deleted instructions in
 /// a node, and insert new (lowered) instructions at the current point. Along
 /// with the instruction list container and associated iterators, it holds the