[dfmc] Propagate not-inline to generated code.

When a function is flagged as not-inline in Dylan, it is useful for
that information to be passed along to C and LLVM to prevent it from
being inlined during code generation.

This is particularly useful in tests where you want to prevent the
compiler from optimizing away the thing that you're testing.

* sources/dfmc/llvm-back-end/llvm-emit-code.dylan
  (llvm-function-attributes): New.
  (emit-code): Get function attributes and pass them along to the
   <llvm-function>.

* sources/dfmc/c-back-end/c-emit-object.dylan
  (emit-lambda-interface-using-function): Pass not-inline along to
   the generated C function.

* sources/lib/run-time/run-time.h
  (OPEN_DYLAN_NO_INLINE): New portability macro.

documentation/release-notes/source/2015.1.rst

@@ -66,6 +66,9 @@ Compiler
   * Previously, ``define domain`` was accepted without warning. This is
     not valid Dylan syntax as it should be ``define sealed domain``.
 
+* Dylan functions that are marked as ``not-inline`` now take that into
+  account when generating code in the LLVM and C back-ends.
+
 Documentation
 =============
 

sources/dfmc/c-back-end/c-emit-object.dylan

@@ -657,6 +657,10 @@ define method emit-lambda-interface-using-function
   unless (external-lambda?(fun))
     write(stream, "static ");
   end;
+  let form = fn.model-definition;
+  if (form & form.form-inline-policy == #"not-inline")
+    write(stream, "OPEN_DYLAN_NO_INLINE ");
+  end if;
   emit-return-types(back-end, stream, o);
   format-emit*(back-end, stream, " ^ ", o);
   let sig = ^function-signature(fn);

sources/dfmc/llvm-back-end/llvm-emit-code.dylan

@@ -138,6 +138,7 @@ define method emit-code
                 arguments: concatenate(arguments,
                                        extra,
                                        calling-convention-parameters),
+                attribute-list: llvm-function-attributes(back-end, o),
                 linkage: linkage,
                 section: llvm-section-name(back-end, section),
                 calling-convention:
@@ -237,3 +238,22 @@ define method llvm-calling-convention
   $llvm-calling-convention-c
 end method;
 
+define method llvm-function-attributes
+    (back-end :: <llvm-back-end>, o :: <&iep>)
+ => (attributes :: <llvm-attribute-list>)
+  let function-attributes = $llvm-attribute-none;
+  let parameter-attributes = #[];
+  let return-attributes = $llvm-attribute-none;
+  let form = o.function.model-definition;
+  if (form)
+    select (form.form-inline-policy)
+      #"not-inline" =>
+        function-attributes := llvm-attribute-merge(function-attributes, $llvm-attribute-noinline);
+      otherwise =>
+    end select;
+  end if;
+  make(<llvm-attribute-list>,
+       return-attributes: return-attributes,
+       function-attributes: function-attributes,
+       parameter-attributes: parameter-attributes)
+end method;

sources/lib/run-time/run-time.h

@@ -92,6 +92,13 @@ typedef void*                   D;
 
 /* COMPILER-SPECIFIC INTRINSICS */
 
+
+#ifdef OPEN_DYLAN_COMPILER_GCC_LIKE
+#  define OPEN_DYLAN_NO_INLINE __attribute__((noinline))
+#else
+#  define OPEN_DYLAN_NO_INLINE
+#endif
+
 #ifdef OPEN_DYLAN_COMPILER_GCC_LIKE
 #  define NORETURN_FUNCTION __attribute__((noreturn))
 #else