2018-02-04 00:49:21 -05:00
|
|
|
# Copyright (C) 2017 Vladimir Makarov, <vmakarov@redhat.com>
|
|
|
|
# This is a script to transform functions to static inline.
|
|
|
|
# Usage: transform_mjit_header.rb <c-compiler> <header file> <out>
|
|
|
|
|
|
|
|
require 'fileutils'
|
|
|
|
require 'tempfile'
|
|
|
|
|
2018-02-04 21:07:49 -05:00
|
|
|
PROGRAM = File.basename($0, ".*")
|
|
|
|
|
2018-02-04 00:49:21 -05:00
|
|
|
module MJITHeader
|
|
|
|
ATTR_VALUE_REGEXP = /[^()]|\([^()]*\)/
|
2018-02-06 07:40:41 -05:00
|
|
|
ATTR_REGEXP = /__attribute__\s*\(\(#{ATTR_VALUE_REGEXP}*\)\)/
|
2018-07-31 07:18:59 -04:00
|
|
|
# Example:
|
|
|
|
# VALUE foo(int bar)
|
|
|
|
# VALUE __attribute__ ((foo)) bar(int baz)
|
|
|
|
# __attribute__ ((foo)) VALUE bar(int baz)
|
2018-07-31 08:55:28 -04:00
|
|
|
FUNC_HEADER_REGEXP = /\A[^\[{(]*(\s*#{ATTR_REGEXP})*[^\[{(]*\((#{ATTR_REGEXP}|[^()])*\)(\s*#{ATTR_REGEXP})*\s*/
|
2018-09-11 07:26:15 -04:00
|
|
|
TARGET_NAME_REGEXP = /\A(rb|ruby|vm|insn|attr|Init)_/
|
2018-02-04 00:49:21 -05:00
|
|
|
|
2018-02-07 08:48:48 -05:00
|
|
|
# Predefined macros for compilers which are already supported by MJIT.
|
|
|
|
# We're going to support cl.exe too (WIP) but `cl.exe -E` can't produce macro.
|
|
|
|
SUPPORTED_CC_MACROS = [
|
|
|
|
'__GNUC__', # gcc
|
|
|
|
'__clang__', # clang
|
|
|
|
]
|
|
|
|
|
2018-03-06 07:53:19 -05:00
|
|
|
# These macros are relied on this script's transformation
|
|
|
|
PREFIXED_MACROS = [
|
|
|
|
'ALWAYS_INLINE',
|
2018-10-19 08:29:47 -04:00
|
|
|
'inline',
|
2018-03-06 07:53:19 -05:00
|
|
|
]
|
|
|
|
|
2018-02-04 00:49:21 -05:00
|
|
|
# For MinGW's ras.h. Those macros have its name in its definition and can't be preprocessed multiple times.
|
|
|
|
RECURSIVE_MACROS = %w[
|
|
|
|
RASCTRYINFO
|
|
|
|
RASIPADDR
|
|
|
|
]
|
|
|
|
|
|
|
|
IGNORED_FUNCTIONS = [
|
2018-07-24 10:43:40 -04:00
|
|
|
'rb_vm_search_method_slowpath', # This increases the time to compile when inlined. So we use it as external function.
|
2018-02-04 00:49:21 -05:00
|
|
|
'rb_equal_opt', # Not used from VM and not compilable
|
|
|
|
]
|
|
|
|
|
2018-03-06 07:53:19 -05:00
|
|
|
ALWAYS_INLINED_FUNCTIONS = [
|
|
|
|
'vm_opt_plus',
|
|
|
|
'vm_opt_minus',
|
|
|
|
'vm_opt_mult',
|
|
|
|
'vm_opt_div',
|
|
|
|
'vm_opt_mod',
|
|
|
|
'vm_opt_neq',
|
|
|
|
'vm_opt_lt',
|
|
|
|
'vm_opt_le',
|
|
|
|
'vm_opt_gt',
|
|
|
|
'vm_opt_ge',
|
|
|
|
'vm_opt_ltlt',
|
2018-09-25 22:38:45 -04:00
|
|
|
'vm_opt_and',
|
|
|
|
'vm_opt_or',
|
2018-03-06 07:53:19 -05:00
|
|
|
'vm_opt_aref',
|
|
|
|
'vm_opt_aset',
|
|
|
|
'vm_opt_aref_with',
|
|
|
|
'vm_opt_aset_with',
|
|
|
|
'vm_opt_not',
|
2018-03-07 09:35:28 -05:00
|
|
|
'vm_getinstancevariable',
|
|
|
|
'vm_setinstancevariable',
|
|
|
|
'vm_setivar',
|
2018-03-06 07:53:19 -05:00
|
|
|
]
|
|
|
|
|
2018-02-04 00:49:21 -05:00
|
|
|
# Return start..stop of last decl in CODE ending STOP
|
|
|
|
def self.find_decl(code, stop)
|
|
|
|
level = 0
|
2018-02-04 19:52:20 -05:00
|
|
|
i = stop
|
|
|
|
while i = code.rindex(/[;{}]/, i)
|
|
|
|
if level == 0 && stop != i && decl_found?($&, i)
|
|
|
|
return decl_start($&, i)..stop
|
|
|
|
end
|
|
|
|
case $&
|
|
|
|
when '}'
|
2018-02-04 00:49:21 -05:00
|
|
|
level += 1
|
2018-02-04 19:52:20 -05:00
|
|
|
when '{'
|
2018-02-04 00:49:21 -05:00
|
|
|
level -= 1
|
|
|
|
end
|
2018-02-04 19:52:20 -05:00
|
|
|
i -= 1
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
2018-02-04 19:52:20 -05:00
|
|
|
nil
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.decl_found?(code, i)
|
2018-02-04 19:52:20 -05:00
|
|
|
i == 0 || code == ';' || code == '}'
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.decl_start(code, i)
|
2018-02-04 19:52:20 -05:00
|
|
|
if i == 0 && code != ';' && code != '}'
|
2018-02-04 00:49:21 -05:00
|
|
|
0
|
|
|
|
else
|
|
|
|
i + 1
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Given DECL return the name of it, nil if failed
|
|
|
|
def self.decl_name_of(decl)
|
|
|
|
ident_regex = /\w+/
|
|
|
|
decl = decl.gsub(/^#.+$/, '') # remove macros
|
2018-02-04 06:59:19 -05:00
|
|
|
reduced_decl = decl.gsub(ATTR_REGEXP, '') # remove attributes
|
2018-02-04 00:49:21 -05:00
|
|
|
su1_regex = /{[^{}]*}/
|
2018-02-04 06:59:19 -05:00
|
|
|
su2_regex = /{([^{}]|#{su1_regex})*}/
|
|
|
|
su3_regex = /{([^{}]|#{su2_regex})*}/ # 3 nested structs/unions is probably enough
|
|
|
|
reduced_decl.gsub!(su3_regex, '') # remove structs/unions in the header
|
2018-02-04 00:49:21 -05:00
|
|
|
id_seq_regex = /\s*(#{ident_regex}(\s+|\s*[*]+\s*))*/
|
|
|
|
# Process function header:
|
|
|
|
match = /\A#{id_seq_regex}(?<name>#{ident_regex})\s*\(/.match(reduced_decl)
|
|
|
|
return match[:name] if match
|
|
|
|
# Process non-function declaration:
|
|
|
|
reduced_decl.gsub!(/\s*=[^;]+(?=;)/, '') # remove initialization
|
|
|
|
match = /#{id_seq_regex}(?<name>#{ident_regex})/.match(reduced_decl);
|
|
|
|
return match[:name] if match
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
|
|
|
# Return true if CC with CFLAGS compiles successfully the current code.
|
|
|
|
# Use STAGE in the message in case of a compilation failure
|
|
|
|
def self.check_code!(code, cc, cflags, stage)
|
2018-02-08 19:00:27 -05:00
|
|
|
with_code(code) do |path|
|
|
|
|
cmd = "#{cc} #{cflags} #{path}"
|
2018-03-16 22:18:46 -04:00
|
|
|
out = IO.popen(cmd, err: [:child, :out], &:read)
|
|
|
|
unless $?.success?
|
2018-02-06 08:47:02 -05:00
|
|
|
STDERR.puts "error in #{stage} header file:\n#{out}"
|
2018-02-06 09:58:12 -05:00
|
|
|
exit false
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Remove unpreprocessable macros
|
|
|
|
def self.remove_harmful_macros!(code)
|
|
|
|
code.gsub!(/^#define #{Regexp.union(RECURSIVE_MACROS)} .*$/, '')
|
|
|
|
end
|
|
|
|
|
2018-02-05 07:05:04 -05:00
|
|
|
# -dD outputs those macros, and it produces redefinition warnings or errors
|
2018-02-11 00:29:13 -05:00
|
|
|
# This assumes common.mk passes `-DMJIT_HEADER` first when it creates rb_mjit_header.h.
|
2018-02-05 07:05:04 -05:00
|
|
|
def self.remove_predefined_macros!(code)
|
|
|
|
code.sub!(/\A(#define [^\n]+|\n)*(#define MJIT_HEADER 1\n)/, '\2')
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
2018-03-06 07:53:19 -05:00
|
|
|
# Return [macro, others]. But others include PREFIXED_MACROS to be used in code.
|
2018-02-04 00:49:21 -05:00
|
|
|
def self.separate_macro_and_code(code)
|
2018-03-06 07:53:19 -05:00
|
|
|
code.lines.partition do |l|
|
|
|
|
l.start_with?('#') && PREFIXED_MACROS.all? { |m| !l.start_with?("#define #{m}") }
|
|
|
|
end.map! { |lines| lines.join('') }
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.write(code, out)
|
|
|
|
FileUtils.mkdir_p(File.dirname(out))
|
2018-02-04 21:02:23 -05:00
|
|
|
File.binwrite("#{out}.new", code)
|
2018-02-04 00:49:21 -05:00
|
|
|
FileUtils.mv("#{out}.new", out)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Note that this checks runruby. This conservatively covers platform names.
|
|
|
|
def self.windows?
|
|
|
|
RUBY_PLATFORM =~ /mswin|mingw|msys/
|
|
|
|
end
|
2018-02-07 08:48:48 -05:00
|
|
|
|
|
|
|
def self.cl_exe?(cc)
|
|
|
|
cc =~ /\Acl(\z| |\.exe)/
|
|
|
|
end
|
|
|
|
|
|
|
|
# If code has macro which only supported compilers predefine, return true.
|
|
|
|
def self.supported_header?(code)
|
2018-02-07 09:01:51 -05:00
|
|
|
SUPPORTED_CC_MACROS.any? { |macro| code =~ /^#\s*define\s+#{Regexp.escape(macro)}\b/ }
|
2018-02-07 08:48:48 -05:00
|
|
|
end
|
2018-02-08 19:00:27 -05:00
|
|
|
|
2018-05-11 12:47:38 -04:00
|
|
|
# This checks if syntax check outputs one of the following messages.
|
|
|
|
# "error: conflicting types for 'restrict'"
|
|
|
|
# "error: redefinition of parameter 'restrict'"
|
|
|
|
# If it's true, this script regards platform as AIX or Solaris and adds -std=c99 as workaround.
|
2018-02-08 19:00:27 -05:00
|
|
|
def self.conflicting_types?(code, cc, cflags)
|
|
|
|
with_code(code) do |path|
|
|
|
|
cmd = "#{cc} #{cflags} #{path}"
|
|
|
|
out = IO.popen(cmd, err: [:child, :out], &:read)
|
2018-05-11 12:47:38 -04:00
|
|
|
!$?.success? &&
|
|
|
|
(out.match?(/error: conflicting types for '[^']+'/) ||
|
|
|
|
out.match?(/error: redefinition of parameter '[^']+'/))
|
2018-02-08 19:00:27 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def self.with_code(code)
|
2018-10-19 08:29:46 -04:00
|
|
|
# for `system_header` pragma which can't be in the main file.
|
|
|
|
Tempfile.open(['', '.h'], mode: File::BINARY) do |f|
|
2018-02-08 19:00:27 -05:00
|
|
|
f.puts code
|
|
|
|
f.close
|
2018-10-19 08:29:46 -04:00
|
|
|
Tempfile.open(['', '.c'], mode: File::BINARY) do |c|
|
|
|
|
c.puts <<SRC
|
|
|
|
#include "#{f.path}"
|
|
|
|
SRC
|
|
|
|
c.close
|
|
|
|
return yield(c.path)
|
|
|
|
end
|
2018-02-08 19:00:27 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
private_class_method :with_code
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
if ARGV.size != 3
|
2018-02-04 21:07:49 -05:00
|
|
|
abort "Usage: #{$0} <c-compiler> <header file> <out>"
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
cc = ARGV[0]
|
2018-02-04 21:02:23 -05:00
|
|
|
code = File.binread(ARGV[1]) # Current version of the header file.
|
2018-02-04 00:49:21 -05:00
|
|
|
outfile = ARGV[2]
|
2018-02-07 08:48:48 -05:00
|
|
|
if MJITHeader.cl_exe?(cc)
|
2018-02-04 00:49:21 -05:00
|
|
|
cflags = '-DMJIT_HEADER -Zs'
|
|
|
|
else
|
|
|
|
cflags = '-S -DMJIT_HEADER -fsyntax-only -Werror=implicit-function-declaration -Werror=implicit-int -Wfatal-errors'
|
|
|
|
end
|
|
|
|
|
2018-02-07 08:48:48 -05:00
|
|
|
if !MJITHeader.cl_exe?(cc) && !MJITHeader.supported_header?(code)
|
|
|
|
puts "This compiler (#{cc}) looks not supported for MJIT. Giving up to generate MJIT header."
|
|
|
|
MJITHeader.write("#error MJIT does not support '#{cc}' yet", outfile)
|
|
|
|
exit
|
|
|
|
end
|
|
|
|
|
2018-02-05 07:05:04 -05:00
|
|
|
MJITHeader.remove_predefined_macros!(code)
|
2018-02-04 00:49:21 -05:00
|
|
|
|
|
|
|
if MJITHeader.windows? # transformation is broken with Windows headers for now
|
2018-02-08 19:00:27 -05:00
|
|
|
MJITHeader.remove_harmful_macros!(code)
|
2018-02-05 07:19:38 -05:00
|
|
|
MJITHeader.check_code!(code, cc, cflags, 'initial')
|
2018-02-04 08:51:02 -05:00
|
|
|
puts "\nSkipped transforming external functions to static on Windows."
|
2018-02-04 00:49:21 -05:00
|
|
|
MJITHeader.write(code, outfile)
|
2018-02-04 08:51:02 -05:00
|
|
|
exit
|
2018-02-08 19:00:27 -05:00
|
|
|
end
|
2018-02-05 07:19:38 -05:00
|
|
|
|
2018-02-08 19:00:27 -05:00
|
|
|
macro, code = MJITHeader.separate_macro_and_code(code) # note: this does not work on MinGW
|
2018-10-19 09:11:33 -04:00
|
|
|
code = <<header + code
|
2018-10-19 08:29:46 -04:00
|
|
|
#ifdef __GNUC__
|
|
|
|
# pragma GCC system_header
|
|
|
|
#endif
|
|
|
|
header
|
2018-10-19 09:11:33 -04:00
|
|
|
code_to_check = "#{code}#{macro}" # macro should not affect code again
|
2018-02-08 19:00:27 -05:00
|
|
|
|
|
|
|
if MJITHeader.conflicting_types?(code_to_check, cc, cflags)
|
2018-02-09 08:14:17 -05:00
|
|
|
cflags = "#{cflags} -std=c99" # For AIX gcc
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
2018-02-08 19:00:27 -05:00
|
|
|
|
|
|
|
# Check initial file correctness in the manner of final output.
|
|
|
|
MJITHeader.check_code!(code_to_check, cc, cflags, 'initial')
|
2018-02-04 08:51:02 -05:00
|
|
|
puts "\nTransforming external functions to static:"
|
2018-02-04 00:49:21 -05:00
|
|
|
|
2018-02-04 19:52:20 -05:00
|
|
|
stop_pos = -1
|
2018-02-04 00:49:21 -05:00
|
|
|
extern_names = []
|
|
|
|
|
|
|
|
# This loop changes function declarations to static inline.
|
2018-02-04 19:52:20 -05:00
|
|
|
while (decl_range = MJITHeader.find_decl(code, stop_pos))
|
2018-02-04 00:49:21 -05:00
|
|
|
stop_pos = decl_range.begin - 1
|
|
|
|
decl = code[decl_range]
|
|
|
|
decl_name = MJITHeader.decl_name_of(decl)
|
|
|
|
|
|
|
|
if MJITHeader::IGNORED_FUNCTIONS.include?(decl_name) && /#{MJITHeader::FUNC_HEADER_REGEXP}{/.match(decl)
|
2018-02-04 21:07:49 -05:00
|
|
|
puts "#{PROGRAM}: changing definition of '#{decl_name}' to declaration"
|
2018-02-04 00:49:21 -05:00
|
|
|
code[decl_range] = decl.sub(/{.+}/m, ';')
|
2018-03-06 07:53:19 -05:00
|
|
|
elsif MJITHeader::ALWAYS_INLINED_FUNCTIONS.include?(decl_name) && match = /#{MJITHeader::FUNC_HEADER_REGEXP}{/.match(decl)
|
|
|
|
header = match[0].sub(/{\z/, '').strip
|
|
|
|
header = "static inline #{header.sub(/\A((static|inline) )+/, '')}"
|
|
|
|
decl[match.begin(0)...match.end(0)] = '{' # remove header
|
|
|
|
code[decl_range] = "\nALWAYS_INLINE(#{header});\n#{header} #{decl}"
|
2018-02-04 00:49:21 -05:00
|
|
|
elsif extern_names.include?(decl_name) && (decl =~ /#{MJITHeader::FUNC_HEADER_REGEXP};/)
|
|
|
|
decl.sub!(/(extern|static|inline) /, ' ')
|
|
|
|
unless decl_name =~ /\Aattr_\w+_\w+\z/ # skip too-many false-positive warnings in insns_info.inc.
|
2018-02-04 21:07:49 -05:00
|
|
|
puts "#{PROGRAM}: making declaration of '#{decl_name}' static inline"
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
code[decl_range] = "static inline #{decl}"
|
|
|
|
elsif (match = /#{MJITHeader::FUNC_HEADER_REGEXP}{/.match(decl)) && (header = match[0]) !~ /static/
|
2018-02-05 10:39:55 -05:00
|
|
|
unless decl_name.match(MJITHeader::TARGET_NAME_REGEXP)
|
|
|
|
puts "#{PROGRAM}: SKIPPED to transform #{decl_name}"
|
|
|
|
next
|
|
|
|
end
|
|
|
|
|
2018-02-04 00:49:21 -05:00
|
|
|
extern_names << decl_name
|
|
|
|
decl[match.begin(0)...match.end(0)] = ''
|
|
|
|
|
2018-02-04 08:12:57 -05:00
|
|
|
if decl =~ /\bstatic\b/
|
2018-02-04 08:51:02 -05:00
|
|
|
puts "warning: a static decl inside external definition of '#{decl_name}'"
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
header.sub!(/(extern|inline) /, ' ')
|
|
|
|
unless decl_name =~ /\Aattr_\w+_\w+\z/ # skip too-many false-positive warnings in insns_info.inc.
|
2018-02-04 21:07:49 -05:00
|
|
|
puts "#{PROGRAM}: making external definition of '#{decl_name}' static inline"
|
2018-02-04 00:49:21 -05:00
|
|
|
end
|
|
|
|
code[decl_range] = "static inline #{header}#{decl}"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-02-04 19:52:45 -05:00
|
|
|
code << macro
|
|
|
|
|
2018-02-04 00:49:21 -05:00
|
|
|
# Check the final file correctness
|
|
|
|
MJITHeader.check_code!(code, cc, cflags, 'final')
|
|
|
|
|
|
|
|
MJITHeader.write(code, outfile)
|