Initial commit.

llvm-svn: 147756

Author: pcc

libclc/CREDITS.TXT

@@ -0,0 +1,2 @@
+N: Peter Collingbourne
+E: peter@pcc.me.uk

libclc/LICENSE.TXT

@@ -0,0 +1,29 @@
+Copyright (c) 2011 by the contributors listed in CREDITS.TXT
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * The names of the contributors may not be used to endorse or promote
+      products derived from this Software without specific prior written
+      permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.

libclc/README.TXT

@@ -0,0 +1,37 @@
+libclc
+------
+
+libclc is an open source, BSD licensed implementation of the library
+requirements of the OpenCL C programming language, as specified by the
+OpenCL 1.1 Specification. The following sections of the specification
+impose library requirements:
+
+  * 6.1: Supported Data Types
+  * 6.2.3: Explicit Conversions
+  * 6.2.4.2: Reinterpreting Types Using as_type() and as_typen()
+  * 6.9: Preprocessor Directives and Macros
+  * 6.11: Built-in Functions
+  * 9.3: Double Precision Floating-Point
+  * 9.4: 64-bit Atomics
+  * 9.5: Writing to 3D image memory objects
+  * 9.6: Half Precision Floating-Point
+
+libclc is intended to be used with the Clang compiler's OpenCL frontend.
+
+libclc is designed to be portable and extensible. To this end, it provides
+generic implementations of most library requirements, allowing the target
+to override the generic implementation at the granularity of individual
+functions.
+
+libclc currently only supports the PTX target, but support for more
+targets is welcome.
+
+Compiling
+---------
+
+./configure.py --with-llvm-config=/path/to/llvm-config && make
+
+Website
+-------
+
+http://www.pcc.me.uk/~peter/libclc/

libclc/build/metabuild.py

@@ -0,0 +1,91 @@
+import ninja_syntax
+import os
+
+# Simple meta-build system.
+
+class Make(object):
+  def __init__(self):
+    self.output = open(self.output_filename(), 'w')
+    self.rules = {}
+    self.rule_text = ''
+    self.all_targets = []
+    self.clean_files = []
+    self.distclean_files = []
+    self.output.write("""all::
+
+ifndef VERBOSE
+  Verb = @
+endif
+
+""")
+
+  def output_filename(self):
+    return 'Makefile'
+
+  def rule(self, name, command, description=None, depfile=None,
+           generator=False):
+    self.rules[name] = {'command': command, 'description': description,
+                        'depfile': depfile, 'generator': generator}
+
+  def build(self, output, rule, inputs=[], implicit=[], order_only=[]):
+    inputs = self._as_list(inputs)
+    implicit = self._as_list(implicit)
+    order_only = self._as_list(order_only)
+
+    output_dir = os.path.dirname(output)
+    if output_dir != '' and not os.path.isdir(output_dir):
+      os.makedirs(output_dir)
+
+    dollar_in = ' '.join(inputs)
+    subst = lambda text: text.replace('$in', dollar_in).replace('$out', output)
+
+    deps = ' '.join(inputs + implicit)
+    if order_only:
+      deps += ' | '
+      deps += ' '.join(order_only)
+    self.output.write('%s: %s\n' % (output, deps))
+
+    r = self.rules[rule]
+    command = subst(r['command'])
+    if r['description']:
+      desc = subst(r['description'])
+      self.output.write('\t@echo %s\n\t$(Verb) %s\n' % (desc, command))
+    else:
+      self.output.write('\t%s\n' % command)
+    if r['depfile']:
+      depfile = subst(r['depfile'])
+      self.output.write('-include '+depfile+'\n')
+    self.output.write('\n')
+
+    self.all_targets.append(output)
+    if r['generator']:
+      self.distclean_files.append(output)
+    else:
+      self.clean_files.append(output)
+
+  def _as_list(self, input):
+    if isinstance(input, list):
+      return input
+    return [input]
+
+  def finish(self):
+    self.output.write('all:: %s\n\n' % ' '.join(self.all_targets))
+    self.output.write('clean: \n\trm -f %s\n\n' % ' '.join(self.clean_files))
+    self.output.write('distclean: clean\n\trm -f %s\n' % ' '.join(self.distclean_files))
+
+class Ninja(ninja_syntax.Writer):
+  def __init__(self):
+    ninja_syntax.Writer.__init__(self, open(self.output_filename(), 'w'))
+
+  def output_filename(self):
+    return 'build.ninja'
+
+  def finish(self):
+    pass
+
+def from_name(name):
+  if name == 'make':
+    return Make()
+  if name == 'ninja':
+    return Ninja()
+  raise LookupError, 'unknown generator: %s; supported generators are make and ninja' % name

libclc/build/ninja_syntax.py

@@ -0,0 +1,110 @@
+#!/usr/bin/python
+
+"""Python module for generating .ninja files.
+
+Note that this is emphatically not a required piece of Ninja; it's
+just a helpful utility for build-file-generation systems that already
+use Python.
+"""
+
+import textwrap
+
+class Writer(object):
+    def __init__(self, output, width=78):
+        self.output = output
+        self.width = width
+
+    def newline(self):
+        self.output.write('\n')
+
+    def comment(self, text):
+        for line in textwrap.wrap(text, self.width - 2):
+            self.output.write('# ' + line + '\n')
+
+    def variable(self, key, value, indent=0):
+        if value is None:
+            return
+        if isinstance(value, list):
+            value = ' '.join(value)
+        self._line('%s = %s' % (key, value), indent)
+
+    def rule(self, name, command, description=None, depfile=None,
+             generator=False):
+        self._line('rule %s' % name)
+        self.variable('command', command, indent=1)
+        if description:
+            self.variable('description', description, indent=1)
+        if depfile:
+            self.variable('depfile', depfile, indent=1)
+        if generator:
+            self.variable('generator', '1', indent=1)
+
+    def build(self, outputs, rule, inputs=None, implicit=None, order_only=None,
+              variables=None):
+        outputs = self._as_list(outputs)
+        all_inputs = self._as_list(inputs)[:]
+
+        if implicit:
+            all_inputs.append('|')
+            all_inputs.extend(self._as_list(implicit))
+        if order_only:
+            all_inputs.append('||')
+            all_inputs.extend(self._as_list(order_only))
+
+        self._line('build %s: %s %s' % (' '.join(outputs),
+                                        rule,
+                                        ' '.join(all_inputs)))
+
+        if variables:
+            for key, val in variables:
+                self.variable(key, val, indent=1)
+
+        return outputs
+
+    def include(self, path):
+        self._line('include %s' % path)
+
+    def subninja(self, path):
+        self._line('subninja %s' % path)
+
+    def default(self, paths):
+        self._line('default %s' % ' '.join(self._as_list(paths)))
+
+    def _line(self, text, indent=0):
+        """Write 'text' word-wrapped at self.width characters."""
+        leading_space = '  ' * indent
+        while len(text) > self.width:
+            # The text is too wide; wrap if possible.
+
+            # Find the rightmost space that would obey our width constraint.
+            available_space = self.width - len(leading_space) - len(' $')
+            space = text.rfind(' ', 0, available_space)
+            if space < 0:
+                # No such space; just use the first space we can find.
+                space = text.find(' ', available_space)
+            if space < 0:
+                # Give up on breaking.
+                break
+
+            self.output.write(leading_space + text[0:space] + ' $\n')
+            text = text[space+1:]
+
+            # Subsequent lines are continuations, so indent them.
+            leading_space = '  ' * (indent+2)
+
+        self.output.write(leading_space + text + '\n')
+
+    def _as_list(self, input):
+        if input is None:
+            return []
+        if isinstance(input, list):
+            return input
+        return [input]
+
+
+def escape(string):
+    """Escape a string such that it can be embedded into a Ninja file without
+    further interpretation."""
+    assert '\n' not in string, 'Ninja syntax does not allow newlines'
+    # We only have one special metacharacter: '$'.
+    return string.replace('$', '$$')

libclc/compile-test.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+clang -ccc-host-triple ptx32--nvidiacl -Iptx-nvidiacl/include -Igeneric/include -Xclang -mlink-bitcode-file -Xclang ptx32--nvidiacl/lib/builtins.bc -include clc/clc.h -Dcl_clang_storage_class_specifiers "$@"