passenger 3.9.2.beta → 4.0.0.rc4

data/lib/phusion_passenger/platform_info/compiler.rb

@@ -1,5 +1,5 @@
 #  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010, 2011, 2012 Phusion
+#  Copyright (c) 2010-2013 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -22,30 +22,97 @@
 #  THE SOFTWARE.
 
 require 'phusion_passenger/platform_info'
-require 'phusion_passenger/platform_info/operating_system'
 
 module PhusionPassenger
 
 module PlatformInfo
-	def self.gnu_make
-		gmake = find_command('gmake')
-		if !gmake
-			gmake = find_command('make')
-			if gmake
-				if `#{gmake} --version 2>&1` =~ /GNU/
-					return gmake
-				else
-					return nil
-				end
+private
+	def self.detect_language_extension(language)
+		case language
+		when :c
+			return "c"
+		when :cxx
+			return "cpp"
+		else
+			raise ArgumentError, "Unsupported language #{language.inspect}"
+		end
+	end
+	private_class_method :detect_language_extension
+
+	def self.create_compiler_command(language, flags1, flags2, link = false)
+		case language
+		when :c
+			result  = [cc, link ? ENV['EXTRA_PRE_LDFLAGS'] : nil,
+				ENV['EXTRA_PRE_CFLAGS'], flags1, flags2, ENV['EXTRA_CFLAGS'],
+				ENV['EXTRA_LDFLAGS']]
+		when :cxx
+			result  = [cxx, link ? ENV['EXTRA_PRE_LDFLAGS'] : nil,
+				ENV['EXTRA_PRE_CXXFLAGS'], flags1, flags2, ENV['EXTRA_CXXFLAGS'],
+				ENV['EXTRA_LDFLAGS']]
+		else
+			raise ArgumentError, "Unsupported language #{language.inspect}"
+		end
+		return result.compact.join(" ").strip
+	end
+	private_class_method :create_compiler_command
+
+	def self.run_compiler(description, command, source_file, source, capture_output = false)
+		if verbose?
+			message = "#{description}\n" <<
+				"Running: #{command}\n"
+			if source.strip.empty?
+				message << "Source file is empty."
+			else
+				message << "Source file contains:\n" <<
+					"-------------------------\n" <<
+					unindent(source) <<
+					"\n-------------------------"
+			end
+			log(message)
+		end
+		if capture_output
+			begin
+				output = `#{command} 2>&1`
+				result = $?.exitstatus == 0
+			rescue SystemCallError => e
+				result = false
+				exec_error_reason = e.message
+			end
+			log("Output:\n" <<
+				"-------------------------\n" <<
+				output <<
+				"\n-------------------------")
+		elsif verbose?
+			result = system(command)
+		else
+			result = system("(#{command}) >/dev/null 2>/dev/null")
+		end
+		if result.nil?
+			log("Command could not be executed! #{exec_error_reason}".strip)
+			return false
+		elsif result
+			log("Check suceeded")
+			if capture_output
+				return { :output => output }
 			else
-				return nil
+				return true
 			end
 		else
-			return gmake
+			log("Check failed with exit status #{$?.exitstatus}")
+			return false
 		end
 	end
-	memoize :gnu_make, true
+	private_class_method :run_compiler
+
+public
+	def self.cc
+		return string_env('CC', 'gcc')
+	end
 	
+	def self.cxx
+		return string_env('CXX', 'g++')
+	end
+
 	def self.cc_is_clang?
 		`#{cc} --version 2>&1` =~ /clang version/
 	end
@@ -56,29 +123,132 @@ module PlatformInfo
 	end
 	memoize :cxx_is_clang?
 
+
+	# Looks for the given C or C++ header. This works by invoking the compiler and
+	# searching in the compiler's header search path. Returns its full filename,
+	# or true if this function knows that the header exists but can't find it (e.g.
+	# because the compiler cannot tell us what its header search path is).
+	# Returns nil if the header cannot be found.
+	def self.find_header(header_name, language, flags = nil)
+		extension = detect_language_extension(language)
+		create_temp_file("passenger-compile-check.#{extension}") do |filename, f|
+			source = %Q{
+				#include <#{header_name}>
+			}
+			f.puts(source)
+			f.close
+			begin
+				command = create_compiler_command(language,
+					"-v -c '#{filename}' -o '#{filename}.o'",
+					flags)
+				if result = run_compiler("Checking for #{header_name}", command, filename, source, true)
+					result[:output] =~ /^#include <...> search starts here:$(.+?)^End of search list\.$/m
+					search_paths = $1.to_s.strip.split("\n").map{ |line| line.strip }
+					search_paths.each do |dir|
+						if File.file?("#{dir}/#{header_name}")
+							return "#{dir}/#{header_name}"
+						end
+					end
+					return true
+				else
+					return nil
+				end
+			ensure
+				File.unlink("#{filename}.o") rescue nil
+			end
+		end
+	end
+
+	def self.try_compile(description, language, source, flags = nil)
+		extension = detect_language_extension(language)
+		create_temp_file("passenger-compile-check.#{extension}") do |filename, f|
+			f.puts(source)
+			f.close
+			begin
+				command = create_compiler_command(language,
+					"-c '#{filename}' -o '#{filename}.o'",
+					flags)
+				return run_compiler(description, command, filename, source)
+			ensure
+				File.unlink("#{filename}.o") rescue nil
+			end
+		end
+	end
+	
+	def self.try_link(description, language, source, flags = nil)
+		extension = detect_language_extension(language)
+		create_temp_file("passenger-link-check.#{extension}") do |filename, f|
+			f.puts(source)
+			f.close
+			begin
+				command = create_compiler_command(language,
+					"'#{filename}' -o '#{filename}.out'",
+					flags, true)
+				return run_compiler(description, command, filename, source)
+			ensure
+				File.unlink("#{filename}.out") rescue nil
+			end
+		end
+	end
+	
+	def self.try_compile_and_run(description, language, source, flags = nil)
+		extension = detect_language_extension(language)
+		create_temp_file("passenger-run-check.#{extension}", tmpexedir) do |filename, f|
+			f.puts(source)
+			f.close
+			begin
+				command = create_compiler_command(language,
+					"'#{filename}' -o '#{filename}.out'",
+					flags, true)
+				if run_compiler(description, command, filename, source)
+					log("Running #{filename}.out")
+					begin
+						output = `'#{filename}.out' 2>&1`
+					rescue SystemCallError => e
+						log("Command failed: #{e}")
+						return false
+					end
+					status = $?.exitstatus
+					log("Command exited with status #{status}. Output:\n--------------\n#{output}\n--------------")
+					return status == 0
+				else
+					return false
+				end
+			ensure
+				File.unlink("#{filename}.out") rescue nil
+			end
+		end
+	end
+
+
 	# Checks whether the compiler supports "-arch #{arch}".
 	def self.compiler_supports_architecture?(arch)
-		return try_compile(:c, '', "-arch #{arch}")
+		return try_compile("Checking for C compiler '-arch' support",
+			:c, '', "-arch #{arch}")
 	end
 	
 	def self.compiler_supports_visibility_flag?
 		return false if RUBY_PLATFORM =~ /aix/
-		return try_compile(:c, '', '-fvisibility=hidden')
+		return try_compile("Checking for C compiler '-fvisibility' support",
+			:c, '', '-fvisibility=hidden')
 	end
 	memoize :compiler_supports_visibility_flag?, true
 	
 	def self.compiler_supports_wno_attributes_flag?
-		return try_compile(:c, '', '-Wno-attributes')
+		return try_compile("Checking for C compiler '-Wno-attributes' support",
+			:c, '', '-Wno-attributes')
 	end
 	memoize :compiler_supports_wno_attributes_flag?, true
 
 	def self.compiler_supports_wno_missing_field_initializers_flag?
-		return try_compile(:c, '', '-Wno-missing-field-initializers')
+		return try_compile("Checking for C compiler '-Wno-missing-field-initializers' support",
+			:c, '', '-Wno-missing-field-initializers')
 	end
-	memoize :compiler_supports_wno_missing_field_initializers_flag?
+	memoize :compiler_supports_wno_missing_field_initializers_flag?, true
 	
 	def self.compiler_supports_no_tls_direct_seg_refs_option?
-		return try_compile(:c, '', '-mno-tls-direct-seg-refs')
+		return try_compile("Checking for C compiler '-mno-tls-direct-seg-refs' support",
+			:c, '', '-mno-tls-direct-seg-refs')
 	end
 	memoize :compiler_supports_no_tls_direct_seg_refs_option?, true
 	
@@ -98,125 +268,16 @@ module PlatformInfo
 	memoize :compiler_visibility_flag_generates_warnings?, true
 	
 	def self.has_math_library?
-		return try_link(:c, "int main() { return 0; }\n", '-lmath')
+		return try_link("Checking for -lmath support",
+			:c, "int main() { return 0; }\n", '-lmath')
 	end
 	memoize :has_math_library?, true
 	
 	def self.has_alloca_h?
-		return try_compile(:c, '#include <alloca.h>')
+		return try_compile("Checking for alloca.h",
+			:c, '#include <alloca.h>')
 	end
 	memoize :has_alloca_h?, true
-
-	# Compiler flags that should be used for compiling every C/C++ program,
-	# for portability reasons. These flags should be specified as last
-	# when invoking the compiler.
-	def self.portability_cflags
-		flags = ["-D_REENTRANT -I/usr/local/include"]
-		
-		# There are too many implementations of of the hash map!
-		# Figure out the right one.
-		ok = try_compile(:cxx, %Q{
-			#include <tr1/unordered_map>
-			int
-			main() {
-				std::tr1::unordered_map<int, int> m;
-				return 0;
-			}
-		})
-		if ok
-			flags << "-DHAS_TR1_UNORDERED_MAP"
-		else
-			hash_namespace = nil
-			ok = false
-			['__gnu_cxx', '', 'std', 'stdext'].each do |namespace|
-				['hash_map', 'ext/hash_map'].each do |hash_map_header|
-					ok = try_compile(:cxx, %Q{
-						#include <#{hash_map_header}>
-						int
-						main() {
-							#{namespace}::hash_map<int, int> m;
-							return 0;
-						}
-					})
-					if ok
-						hash_namespace = namespace
-						flags << "-DHASH_NAMESPACE=\"#{namespace}\""
-						flags << "-DHASH_MAP_HEADER=\"<#{hash_map_header}>\""
-						flags << "-DHASH_MAP_CLASS=\"hash_map\""
-					end
-					break if ok
-				end
-				break if ok
-			end
-			['ext/hash_fun.h', 'functional', 'tr1/functional',
-			 'ext/stl_hash_fun.h', 'hash_fun.h', 'stl_hash_fun.h',
-			 'stl/_hash_fun.h'].each do |hash_function_header|
-				ok = try_compile(:cxx, %Q{
-					#include <#{hash_function_header}>
-					int
-					main() {
-						#{hash_namespace}::hash<int>()(5);
-						return 0;
-					}
-				})
-				if ok
-					flags << "-DHASH_FUN_H=\"<#{hash_function_header}>\""
-					break
-				end
-			end
-		end
-
-		ok = try_compile(:c, %Q{
-			#define _GNU_SOURCE
-			#include <sys/socket.h>
-			static void *foo = accept4;
-		})
-		flags << '-DHAVE_ACCEPT4' if ok
-		
-		if RUBY_PLATFORM =~ /solaris/
-			flags << '-pthreads'
-			if RUBY_PLATFORM =~ /solaris2.11/
-				# skip the _XOPEN_SOURCE and _XPG4_2 definitions in later versions of Solaris / OpenIndiana
-				flags << '-D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64'
-			else
-				flags << '-D_XOPEN_SOURCE=500 -D_XPG4_2 -D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64'
-				flags << '-D__SOLARIS9__ -DBOOST__STDC_CONSTANT_MACROS_DEFINED' if RUBY_PLATFORM =~ /solaris2.9/
-			end
-			flags << '-DBOOST_HAS_STDINT_H' unless RUBY_PLATFORM =~ /solaris2.9/
-			flags << '-mcpu=ultrasparc' if RUBY_PLATFORM =~ /sparc/
-		elsif RUBY_PLATFORM =~ /openbsd/
-			flags << '-DBOOST_HAS_STDINT_H -D_GLIBCPP__PTHREADS'
-		elsif RUBY_PLATFORM =~ /aix/
-			flags << '-pthread'
-			flags << '-DOXT_DISABLE_BACKTRACES'
-		elsif RUBY_PLATFORM =~ /(sparc-linux|arm-linux|^arm.*-linux|sh4-linux)/
-			# http://code.google.com/p/phusion-passenger/issues/detail?id=200
-			# http://groups.google.com/group/phusion-passenger/t/6b904a962ee28e5c
-			# http://groups.google.com/group/phusion-passenger/browse_thread/thread/aad4bd9d8d200561
-			flags << '-DBOOST_SP_USE_PTHREADS'
-		end
-		
-		flags << '-DHAS_ALLOCA_H' if has_alloca_h?
-		flags << '-DHAS_SFENCE' if supports_sfence_instruction?
-		flags << '-DHAS_LFENCE' if supports_lfence_instruction?
-		
-		return flags.compact.join(" ").strip
-	end
-	memoize :portability_cflags, true
-	
-	# Linker flags that should be used for linking every C/C++ program,
-	# for portability reasons. These flags should be specified as last
-	# when invoking the linker.
-	def self.portability_ldflags
-		if RUBY_PLATFORM =~ /solaris/
-			result = '-lxnet -lrt -lsocket -lnsl -lpthread'
-		else
-			result = '-lpthread'
-		end
-		flags << ' -lmath' if has_math_library?
-		return result
-	end
-	memoize :portability_ldflags
 	
 	# C compiler flags that should be passed in order to enable debugging information.
 	def self.debugging_cflags
@@ -272,6 +333,35 @@ module PlatformInfo
 			return nil
 		end
 	end
+
+
+	def self.make
+		return string_env('MAKE', find_command('make'))
+	end
+	memoize :make, true
+
+	def self.gnu_make
+		if result = string_env('GMAKE')
+			return result
+		else
+			result = find_command('gmake')
+			if !result
+				result = find_command('make')
+				if result
+					if `#{result} --version 2>&1` =~ /GNU/
+						return result
+					else
+						return nil
+					end
+				else
+					return nil
+				end
+			else
+				return result
+			end
+		end
+	end
+	memoize :gnu_make, true
 end
 
 end # module PhusionPassenger

data/lib/phusion_passenger/platform_info/cxx_portability.rb

@@ -0,0 +1,143 @@
+#  Phusion Passenger - https://www.phusionpassenger.com/
+#  Copyright (c) 2010-2013 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in 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:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  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
+#  AUTHORS 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 IN
+#  THE SOFTWARE.
+
+require 'phusion_passenger/platform_info'
+require 'phusion_passenger/platform_info/compiler'
+require 'phusion_passenger/platform_info/operating_system'
+
+module PhusionPassenger
+
+module PlatformInfo
+	# Compiler flags that should be used for compiling every C/C++ program,
+	# for portability reasons. These flags should be specified as last
+	# when invoking the compiler.
+	def self.portability_cflags
+		flags = ["-D_REENTRANT -I/usr/local/include"]
+		
+		# There are too many implementations of of the hash map!
+		# Figure out the right one.
+		ok = try_compile("Checking for tr1/unordered_map", :cxx, %Q{
+			#include <tr1/unordered_map>
+			int
+			main() {
+				std::tr1::unordered_map<int, int> m;
+				return 0;
+			}
+		})
+		if ok
+			flags << "-DHAS_TR1_UNORDERED_MAP"
+		else
+			hash_namespace = nil
+			ok = false
+			['__gnu_cxx', '', 'std', 'stdext'].each do |namespace|
+				['hash_map', 'ext/hash_map'].each do |hash_map_header|
+					ok = try_compile("Checking for #{hash_map_header}", :cxx, %Q{
+						#include <#{hash_map_header}>
+						int
+						main() {
+							#{namespace}::hash_map<int, int> m;
+							return 0;
+						}
+					})
+					if ok
+						hash_namespace = namespace
+						flags << "-DHASH_NAMESPACE=\"#{namespace}\""
+						flags << "-DHASH_MAP_HEADER=\"<#{hash_map_header}>\""
+						flags << "-DHASH_MAP_CLASS=\"hash_map\""
+					end
+					break if ok
+				end
+				break if ok
+			end
+			['ext/hash_fun.h', 'functional', 'tr1/functional',
+			 'ext/stl_hash_fun.h', 'hash_fun.h', 'stl_hash_fun.h',
+			 'stl/_hash_fun.h'].each do |hash_function_header|
+				ok = try_compile("Checking for #{hash_function_header}", :cxx, %Q{
+					#include <#{hash_function_header}>
+					int
+					main() {
+						#{hash_namespace}::hash<int>()(5);
+						return 0;
+					}
+				})
+				if ok
+					flags << "-DHASH_FUN_H=\"<#{hash_function_header}>\""
+					break
+				end
+			end
+		end
+
+		ok = try_compile("Checking for accept4()", :c, %Q{
+			#define _GNU_SOURCE
+			#include <sys/socket.h>
+			static void *foo = accept4;
+		})
+		flags << '-DHAVE_ACCEPT4' if ok
+		
+		if RUBY_PLATFORM =~ /solaris/
+			flags << '-pthreads'
+			if RUBY_PLATFORM =~ /solaris2.11/
+				# skip the _XOPEN_SOURCE and _XPG4_2 definitions in later versions of Solaris / OpenIndiana
+				flags << '-D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64'
+			else
+				flags << '-D_XOPEN_SOURCE=500 -D_XPG4_2 -D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64'
+				flags << '-D__SOLARIS9__ -DBOOST__STDC_CONSTANT_MACROS_DEFINED' if RUBY_PLATFORM =~ /solaris2.9/
+			end
+			flags << '-DBOOST_HAS_STDINT_H' unless RUBY_PLATFORM =~ /solaris2.9/
+			flags << '-mcpu=ultrasparc' if RUBY_PLATFORM =~ /sparc/
+		elsif RUBY_PLATFORM =~ /openbsd/
+			flags << '-DBOOST_HAS_STDINT_H -D_GLIBCPP__PTHREADS'
+		elsif RUBY_PLATFORM =~ /aix/
+			flags << '-pthread'
+			flags << '-DOXT_DISABLE_BACKTRACES'
+		elsif RUBY_PLATFORM =~ /(sparc-linux|arm-linux|^arm.*-linux|sh4-linux)/
+			# http://code.google.com/p/phusion-passenger/issues/detail?id=200
+			# http://groups.google.com/group/phusion-passenger/t/6b904a962ee28e5c
+			# http://groups.google.com/group/phusion-passenger/browse_thread/thread/aad4bd9d8d200561
+			flags << '-DBOOST_SP_USE_PTHREADS'
+		end
+		
+		flags << '-DHAS_ALLOCA_H' if has_alloca_h?
+		flags << '-DHAS_SFENCE' if supports_sfence_instruction?
+		flags << '-DHAS_LFENCE' if supports_lfence_instruction?
+		
+		return flags.compact.join(" ").strip
+	end
+	memoize :portability_cflags, true
+
+	# Linker flags that should be used for linking every C/C++ program,
+	# for portability reasons. These flags should be specified as last
+	# when invoking the linker.
+	def self.portability_ldflags
+		if RUBY_PLATFORM =~ /solaris/
+			result = '-lxnet -lrt -lsocket -lnsl -lpthread'
+		else
+			result = '-lpthread'
+		end
+		flags << ' -lmath' if has_math_library?
+		return result
+	end
+	memoize :portability_ldflags
+end
+
+end # module PhusionPassenger