police-dataflow 0.0.1 → 0.0.2

data/lib/police/dataflow/proxying.rb

@@ -6,19 +6,22 @@ module DataFlow
 #
 # ProxyBase is the superclass for all proxy classes, which makes it visible to
 # application code. For this reason, we avoid defining any methods there.
+require 'police/vminfo'
+
 module Proxying
   # Creates a label-holding proxy for an object.
   #
   # @param [Object] proxied the object to be proxied
-  # @param [Array<Integer>] label_keys 
+  # @param [Hash<Integer,Hash<Police::DataFlow::Label,Boolean>>] label_set the
+  #     set of all labels that will be held by the object's proxy
   # @return [Police::DataFlow::ProxyBase] an object that can carry labels, and
   #     performs label-propagation as it redirects received messages to the
   #     proxied object
-  def self.proxy(proxied, label_set, autoflow_set)
+  def self.proxy(proxied, label_set)
     proxy_class = Police::DataFlow::Proxies.for proxied.class, label_set
-    proxy_class.new proxied, proxy_class, label_set, autoflow_set
+    proxy_class.new proxied, proxy_class, label_set
   end
-  
+
   # Creates proxies for a class' instance methods.
   #
   # The proxy methods are defined as instance methods for the proxying class,
@@ -29,17 +32,18 @@ module Proxying
   #     receive the new proxy method definitions
   # @param [Class] klass the class whose instance methods will be proxied
   # @return [NilClass] nil
-  def self.add_class_methods(proxy_class, klass)
+  def self.add_instance_methods(proxy_class, klass)
     # NOTE: this is thread-safe because, at worst, the effort of adding methods
     #       will be re-duplicated
     klass.public_instance_methods(true).each do |method|
-      add_class_method proxy_class, klass.instance_method(method), :public
+      add_instance_method proxy_class, klass.instance_method(method), :public
     end
     klass.protected_instance_methods(true).each do |method|
-      add_class_method proxy_class, klass.instance_method(method), :protected
+      add_instance_method proxy_class, klass.instance_method(method),
+                          :protected
     end
     klass.private_instance_methods(true).each do |method|
-      add_class_method proxy_class, klass.instance_method(method), :private
+      add_instance_method proxy_class, klass.instance_method(method), :private
     end
     nil
   end
@@ -50,20 +54,20 @@ module Proxying
   # @param [Method] method_def the definition of the method to be proxied
   # @param [Symbol] access the proxied method's access level (:public,
   #     :protected, or :private)
-  def self.add_class_method(proxy_class, method_def, access)
+  def self.add_instance_method(proxy_class, method_def, access)
     # Avoid redefining methods, because that blows up VM caches.
     if proxy_class.method_defined?(method_def.name) ||
         proxy_class.private_method_defined?(method_def.name)
       return
     end
-    
+
     # Define the method.
     proxy_class.class_eval proxy_method_definition(
         proxy_class.__police_classes__, method_def, access)
     # Set its access level.
     proxy_class.__send__ access, method_def.name
   end
-  
+
   # The full definition of a proxy method.
   #
   # @param [Array<Police::DataFlow::Label>] label_classes the label classes
@@ -75,46 +79,54 @@ module Proxying
   #     proxy class to define a proxy for the given method
   def self.proxy_method_definition(label_classes, method_def, access)
     # NOTE: it might be tempting to attempt to pass a block to the proxied
-    #       method at all times, and try to yield to the original block when our
-    #       block is invoked; this would work most of the time, but it would
-    #       break methods such as Enumerable#map and String#scan, whose behavior
-    #       changes depending on whether or not a block is passed to them
+    #       method at all times, and try to yield to the original block when
+    #       our block is invoked; this would work most of the time, but it
+    #       would break methods such as Enumerable#map and String#scan, whose
+    #       behavior changes depending on whether or not a block is passed to
+    #       them
     ["def #{method_def.name}(#{proxy_argument_list(method_def, true)})",
+       proxy_sticky_fastpath_check(method_def),
+       proxy_sticky_gathering(method_def),
        "return_value = if block",
-         proxy_method_call(method_def, access, false) + " do |*yield_args|",
+         proxy_method_call(method_def, access) + " do |*yield_args|",
+           proxy_yield_sticky_decorating(method_def),
            proxy_yield_args_decorating(label_classes, method_def),
            "block_return = yield(*yield_args)",
            # TODO(pwnall): consider adding a yield value filter
            "next block_return",
          "end",
        "else",
-         proxy_method_call(method_def, access, false),
+         proxy_method_call(method_def, access),
        "end",
-        proxy_return_decorating(label_classes, method_def),
+
+       proxy_return_sticky_decorating(method_def),
+       proxy_return_decorating(label_classes, method_def),
        "return return_value",
      "end"].join ';'
   end
-  
+
   # The proxying call to a method.
   #
   # @param [Method] method_def the definition of the method to be proxied
   # @param [Symbol] access the proxied method's access level (:public,
   #     :protected, or :private)
-  # @param [Boolean] include_block if true, the method call passes the block
-  #     that the proxy has received; if false, the block is ignored
   # @return [String] a chunk of Ruby that can be used to call the given method
   #     when defining a proxy for it
-  def self.proxy_method_call(method_def, access, include_block)
-    arg_list = proxy_argument_list method_def, include_block
+  def self.proxy_method_call(method_def, access)
+    arg_list = proxy_call_argument_list method_def
 
     if access == :public
       "@__police_proxied__.#{method_def.name}(#{arg_list})"
     else
-      "@__police_proxied__.__send__(:#{method_def.name}, #{arg_list})"
+      if arg_list.empty?
+        "@__police_proxied__.__send__(:#{method_def.name})"
+      else
+        "@__police_proxied__.__send__(:#{method_def.name}, #{arg_list})"
+      end
     end
   end
-  
-  # Code that labels the values yielded by a decorated method to its block. 
+
+  # Code that labels the values yielded by a decorated method to its block.
   #
   # @param [Array<Police::DataFlow::Label>] label_classes the label classes
   #     supported by the proxy class
@@ -126,39 +138,51 @@ module Proxying
     arg_list = proxy_argument_list method_def, false
     code_lines = ['labels = @__police_labels__']
     label_classes.each do |label_class|
-      next unless hook = label_class.yield_args_hook(method_name)
-      label_key = label_class.__id__
-      code_lines << "labels[#{label_key}].each { |label, _| " \
-          "label.#{hook}(self, yield_args, #{arg_list}) }"
+      if hook = label_class.yield_args_hook(method_name)
+        label_key = label_class.__id__
+        code_lines << "labels[#{label_key}].each { |label, _| " \
+            "label.#{hook}(self, yield_args, #{arg_list}) }"
+      elsif label_class.sticky?
+        label_key = label_class.__id__
+        code_lines << "labels[#{label_key}].each { |label, _| " \
+            "yield_args.map! { |arg| ::Police::DataFlow.label(arg, label) } " \
+            "}"
+      end
     end
     (code_lines.length > 1) ? code_lines.join('; ') : ''
   end
-  
+
   # Code that labels return value of a decorated method.
   #
   # @param [Array<Police::DataFlow::Label>] label_classes the label classes
   #     supported by the proxy class
   # @param [Method] method_def the definition of the method to be proxied
-  # @return [String] a chunk of Ruby that can be used to invoke the return value
-  #     decorators of the labels held by a labeled object's proxy
+  # @return [String] a chunk of Ruby that can be used to invoke the return
+  #     value decorators of the labels held by a labeled object's proxy
   def self.proxy_return_decorating(label_classes, method_def)
     method_name = method_def.name
     arg_list = proxy_argument_list method_def, false
     code_lines = ['labels = @__police_labels__']
     label_classes.each do |label_class|
-      next unless hook = label_class.return_hook(method_name)
-      label_key = label_class.__id__
-      code_lines << "labels[#{label_key}].each { |label, _| " \
-          "return_value = label.#{hook}(return_value, self, #{arg_list}) }"
+      if hook = label_class.return_hook(method_name)
+        label_key = label_class.__id__
+        code_lines << "labels[#{label_key}].each { |label, _| " \
+            "return_value = label.#{hook}(return_value, self, #{arg_list}) }"
+      elsif label_class.sticky?
+        label_key = label_class.__id__
+        code_lines << "labels[#{label_key}].each { |label, _| " \
+            "return_value = ::Police::DataFlow.label(return_value, label) }"
+      end
     end
     (code_lines.length > 1) ? code_lines.join('; ') : ''
   end
-  
+
   # The list of arguments used to define a proxy for the given method.
   #
   # @param [Method] method_def the definition of the method to be proxied
-  # @param [Boolean] captue_block if true, the method captures the block that it
-  #     receives
+  # @param [Boolean] captue_block if true, the method captures the block that
+  #     it receives; this should be true when the returned code is used in
+  #     method definitions, and false when it is used in method calls
   # @return [String] a chunk of Ruby that can be used as the argument list when
   #     defining a proxy for the given method
   def self.proxy_argument_list(method_def, capture_block)
@@ -172,6 +196,157 @@ module Proxying
     arg_list << '&block' if capture_block
     arg_list.join ', '
   end
+
+  # The list of arguments used to call a proxied method.
+  #
+  # This assumes that the proxy method definition uses the code retuned by
+  # proxy_argument_list.
+  #
+  # @param [Method] method_def the definition of the method to be proxied;
+  #     should match the value passed to proxy_argument_list
+  # @return [String] a chunk of Ruby that can be used as the argument list when
+  #     defining a proxy for the given method
+  def self.proxy_call_argument_list(method_def)
+    source = Police::VmInfo.method_source method_def
+    if source == :native || source == :kernel
+      proxy_low_level_call_argument_list method_def
+    else
+      proxy_argument_list method_def, false
+    end
+  end
+
+  # The list of arguments used to call a proxied low-level method.
+  #
+  # Low-level methods don't use Ruby methods to manipulate their arguments, so
+  # they can't work on proxies, and need to receive the proxied objects
+  # as arguments.
+  #
+  # @param [Method] method_def the definition of the method to be proxied;
+  #     should match the value passed to {#proxy_argument_list}
+  # @return [String] a chunk of Ruby that can be used as the argument list when
+  #     defining a proxy for the given method
+  def self.proxy_low_level_call_argument_list(method_def)
+    arg_list = if method_def.arity >= 0
+      # Fixed number of arguments.
+      (1..method_def.arity).map do |i|
+        "(nil == arg#{i}.__police_labels__) ? arg#{i} : " +
+            "arg#{i}.__police_proxied__"
+      end
+    else
+      # Variable number of arguments.
+      args_mapper =  '*(args.map { |a| (nil == a.__police_labels__) ? a : ' +
+          'a.__police_proxied__ })'
+      (1..(-method_def.arity - 1)).map { |i|
+        "(nil == arg#{i}.__police_labels__) ? arg#{i} : " +
+            "arg#{i}.__police_proxied__"
+      } << args_mapper
+    end
+    arg_list.join ', '
+  end
+
+  # Boolean expression deciding if a proxied method received labeled arguments.
+  #
+  # If none of the method's arguments is labeled, the sticky label propagation
+  # logic can be completely bypassed.
+  #
+  # @param [Method] method_def the definition of the method to be proxied;
+  #   should match the value passed to {#proxy_argument_list}
+  # @return [String] a chunk of Ruby that sets the 'fast_sticky' local variable
+  #   to a truthy value if none of the proxied method's arguments is labeled,
+  #   and to a falsey value if at least one argument has a label
+  def self.proxy_sticky_fastpath_check(method_def)
+    # Don't generate anything for zero-argument methods.
+    return '' if method_def.arity == 0
+
+    boolean_list = if method_def.arity > 0
+      # Fixed number of arguments.
+      (1..method_def.arity).map do |i|
+        "(nil == arg#{i}.__police_stickies__)"
+      end
+    else
+      # Variable number of arguments.
+      args_boolean = '(args.all? { |a| nil == a.__police_stickies__ })'
+      (1..(-method_def.arity - 1)).map { |i|
+        "(nil == arg#{i}.__police_stickies__)"
+      } << args_boolean
+    end
+    'fast_sticky = ' + boolean_list.join(' && ')
+  end
+
+  # Code for computing the union of the arguments' sticky labels.
+  #
+  # The code is wrapped in a check that assumes the code returned by
+  # {#proxy_sticky_fastpath_check} was already executed.
+  #
+  # @param [Method] method_def the definition of the method to be proxied;
+  #   should match the value passed to {#proxy_argument_list} and
+  #   {#proxy_sticky_fastpath_check}
+  # @return [String] a chunk of Ruby that sets the 'sticky_labels' local
+  #   variable to a label set that contains all the sticky labels in the
+  #   method's arguments
+  def self.proxy_sticky_gathering(method_def)
+    # Don't generate anything for zero-argument methods.
+    return '' if method_def.arity == 0
+
+    code_lines = ['unless fast_sticky', 'sticky_labels = {}']
+    if method_def.arity > 0
+      # Fixed number of arguments.
+      1.upto method_def.arity do |i|
+        code_lines << "unless nil == arg#{i}.__police_stickies__"
+        code_lines <<   '::Police::DataFlow::Labeling.merge_sets!(' +
+                            "sticky_labels, arg#{i}.__police_stickies__)"
+        code_lines << 'end'
+      end
+    else
+      # Variable number of arguments.
+      1.upto(-method_def.arity - 1) do |i|
+        code_lines << "unless nil == arg#{i}.__police_stickies__"
+        code_lines <<   '::Police::DataFlow::Labeling.merge_sets!(' +
+                            "sticky_labels, arg#{i}.__police_stickies__)"
+        code_lines << 'end'
+      end
+      code_lines << 'args.each do |a|'
+      code_lines <<   'unless nil == a.__police_stickies__'
+      code_lines <<     '::Police::DataFlow::Labeling.merge_sets!(' +
+                            'sticky_labels, a.__police_stickies__)'
+      code_lines <<   'end'
+      code_lines << 'end'
+    end
+    code_lines << 'end'
+    code_lines.join '; '
+  end
+
+  # Code for applying argument sticky labels to a method's yielded arguments.
+  #
+  # This code assumes that the code returned by {#proxy_sticky_fastpath_check}
+  # and {#proxy_sticky_gathering} was already executed.
+  #
+  # @param [Method] method_def the definition of the method to be proxied;
+  #   should match the value passed to {#proxy_argument_list} and
+  #   {#proxy_sticky_fastpath_check}
+  # @return [String] a chunk of Ruby that sets the 'sticky_labels' local
+  #   variable to a label set that contains all the sticky labels in the
+  #   method's arguments
+  def self.proxy_yield_sticky_decorating(method_def)
+    # Don't generate anything for zero-argument methods.
+    return '' if method_def.arity == 0
+
+    'unless fast_sticky; ' +
+      'yield_args.map! do |a|; ' +
+        '::Police::DataFlow::Labeling.bulk_sticky_label(a, sticky_labels); ' +
+      'end; ' +
+    'end'
+  end
+
+  def self.proxy_return_sticky_decorating(method_def)
+    # Don't generate anything for zero-argument methods.
+    return '' if method_def.arity == 0
+
+    'unless fast_sticky; ' +
+      'return_value = ::Police::DataFlow::Labeling.bulk_sticky_label(' +
+          'return_value, sticky_labels); ' +
+    'end'
+  end
 end  # namespace Police::DataFlow::Proxying
 
 end  # namespace Police::DataFlow

data/police-dataflow.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "police-dataflow"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Victor Costan"]
-  s.date = "2012-03-28"
+  s.date = "2013-09-24"
   s.description = "Pure Ruby implementtion of data flow label propagation."
   s.email = "victor@costan.us"
   s.extra_rdoc_files = [
@@ -27,36 +27,32 @@ Gem::Specification.new do |s|
     "lib/police-dataflow.rb",
     "lib/police/dataflow.rb",
     "lib/police/dataflow/core_extensions.rb",
-    "lib/police/dataflow/guarding.rb",
+    "lib/police/dataflow/gate_profiles/ruby1.9.3",
+    "lib/police/dataflow/gating.rb",
     "lib/police/dataflow/label.rb",
     "lib/police/dataflow/labeling.rb",
     "lib/police/dataflow/proxies.rb",
     "lib/police/dataflow/proxy_base.rb",
+    "lib/police/dataflow/proxy_numeric.rb",
     "lib/police/dataflow/proxying.rb",
     "police-dataflow.gemspec",
+    "tasks/info.rake",
     "test/dataflow/core_extensions_test.rb",
     "test/dataflow/labeling_test.rb",
     "test/dataflow/proxies_test.rb",
     "test/dataflow/proxy_base_test.rb",
+    "test/dataflow/proxy_numeric_test.rb",
     "test/dataflow/proxying_test.rb",
     "test/helper.rb",
-    "test/helpers/auto_flow_fixture.rb",
+    "test/helpers/hooks_flow_fixture.rb",
     "test/helpers/no_flow_fixture.rb",
-    "test/helpers/proxying_fixture.rb"
+    "test/helpers/proxying_fixture.rb",
+    "test/helpers/sticky_fixture.rb"
   ]
   s.homepage = "http://github.com/csail/police"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.21"
+  s.rubygems_version = "2.0.7"
   s.summary = "Data flow label propagation"
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
 end
 

data/tasks/info.rake

@@ -0,0 +1,43 @@
+task :vminfo do
+  require 'police/vminfo'
+  require 'yaml'
+
+  modules = Set.new
+  class_methods = {}
+  instance_methods = {}
+  Police::VmInfo.core_modules.sort_by(&:to_s).each do |module_object|
+    methods = []
+    Police::VmInfo.core_class_methods(module_object).sort_by(&:to_s).
+                   each do |method|
+      source = Police::VmInfo.method_source(method)
+      next unless source == :native || source == :kernel
+      next if method.arity == 0
+      methods << method.name
+    end
+    unless methods.empty?
+      class_methods[module_object.to_s] = methods.sort
+      modules << module_object.to_s
+    end
+
+    methods = []
+    Police::VmInfo.core_instance_methods(module_object).sort_by(&:to_s).
+                   each do |method|
+      source = Police::VmInfo.method_source(method)
+      next unless source == :native || source == :kernel
+      next if method.arity == 0
+      methods << method.name
+    end
+    unless methods.empty?
+      instance_methods[module_object.to_s] = methods.sort
+      modules << module_object.to_s
+    end
+  end
+
+  profile_path = File.expand_path(
+    "../lib/police/dataflow/gate_profiles/#{Police::VmInfo.signature}",
+    File.dirname(__FILE__))
+  File.open(profile_path, 'w') do |f|
+    f.write YAML.dump(core: modules.to_a.sort, :class => class_methods,
+                      instance: instance_methods)
+  end
+end