Enable warnings when jit compiling (#913)

* Enable warnings when jit compiling

* Formatting

src/targets/gpu/compile_hip_code_object.cpp

@@ -68,6 +68,31 @@ __content__
     return replace_string(args_hpp, "__content__", inner);
 }
 
+const std::vector<std::string>& compiler_warnings()
+{
+    static std::vector<std::string> warnings = {"-Weverything",
+                                                "-Wno-c++98-compat",
+                                                "-Wno-c++98-compat-pedantic",
+                                                "-Wno-conversion",
+                                                "-Wno-double-promotion",
+                                                "-Wno-exit-time-destructors",
+                                                "-Wno-extra-semi",
+                                                "-Wno-extra-semi-stmt",
+                                                "-Wno-float-conversion",
+                                                "-Wno-gnu-anonymous-struct",
+                                                "-Wno-gnu-zero-variadic-macro-arguments",
+                                                "-Wno-missing-prototypes",
+                                                "-Wno-nested-anon-types",
+                                                "-Wno-padded",
+                                                "-Wno-shorten-64-to-32",
+                                                "-Wno-sign-conversion",
+                                                "-Wno-sign-compare",
+                                                "-Wno-unused-command-line-argument",
+                                                "-Wno-weak-vtables",
+                                                "-Wno-c99-extensions"};
+    return warnings;
+}
+
 operation compile_hip_code_object(const std::string& content, hip_compile_options options)
 {
     std::vector<src_file> srcs;
@@ -88,6 +113,8 @@ operation compile_hip_code_object(const std::string& content, hip_compile_option
                             std::make_pair(args_hpp.data(), args_hpp.data() + args_hpp.size())});
     options.params += " -DMIGRAPHX_NGLOBAL=" + std::to_string(options.global);
     options.params += " -DMIGRAPHX_NLOCAL=" + std::to_string(options.local);
+    options.params += " " + join_strings(compiler_warnings(), " ");
+    options.params += " -Werror";
     auto cos = compile_hip_src(srcs, std::move(options.params), get_device_name());
     if(cos.size() != 1)
         MIGRAPHX_THROW("No code object");

src/targets/gpu/kernels/include/migraphx/kernels/preload.hpp

@@ -6,14 +6,6 @@
 
 namespace migraphx {
 
-template <class Shape>
-constexpr bool is_preloadable()
-{
-    Shape s{};
-    if(not s.broadcasted())
-        return false;
-}
-
 template <class T, class... Shapes>
 constexpr auto traverse_preload(Shapes... ss)
 {

test/gpu/jit.cpp

@@ -6,9 +6,11 @@
 #include <migraphx/gpu/kernel.hpp>
 #include <migraphx/gpu/target.hpp>
 #include <migraphx/gpu/hip.hpp>
+#include <migraphx/gpu/context.hpp>
 #include <migraphx/gpu/device_name.hpp>
 #include <migraphx/gpu/compile_hip.hpp>
 #include <migraphx/gpu/compile_hip_code_object.hpp>
+#include <migraphx/gpu/compile_pointwise.hpp>
 
 // NOLINTNEXTLINE
 const std::string write_2s = R"__migraphx__(
@@ -223,4 +225,26 @@ TEST_CASE(compile_code_object_hip)
     EXPECT(result == output_literal.get_argument());
 }
 
+TEST_CASE(compile_pointwise)
+{
+    migraphx::shape input{migraphx::shape::float_type, {5, 2}};
+
+    migraphx::gpu::context ctx;
+    auto co = migraphx::gpu::compile_pointwise(ctx, {input, input}, "[](auto x) { return x + 1; }");
+
+    migraphx::program p;
+    auto* mm            = p.get_main_module();
+    auto input_literal  = migraphx::generate_literal(input);
+    auto output_literal = migraphx::transform(input_literal, [](auto x) { return x + 1; });
+    auto x              = mm->add_literal(input_literal);
+    auto y              = mm->add_parameter("output", input);
+    mm->add_instruction(co, x, y);
+    p.compile(migraphx::gpu::target{}, migraphx::compile_options{});
+
+    auto result =
+        migraphx::gpu::from_gpu(p.eval({{"output", migraphx::gpu::allocate_gpu(input)}}).front());
+
+    EXPECT(result == output_literal.get_argument());
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }