Migrate build system to CMake

See #5895 for details.

This commit does not include CI or documentation changes.

libs/CMakeLists.txt

@@ -0,0 +1,9 @@
+add_subdirectory(bigint)
+add_subdirectory(cxxopts)
+add_subdirectory(dlfcn-win32)
+add_subdirectory(ezsat)
+add_subdirectory(fst)
+add_subdirectory(json11)
+add_subdirectory(minisat)
+add_subdirectory(sha1)
+add_subdirectory(subcircuit)

libs/bigint/CMakeLists.txt

@@ -0,0 +1,14 @@
+yosys_core(bigint
+  BigIntegerAlgorithms.cc
+  BigIntegerAlgorithms.hh
+  BigInteger.cc
+  BigInteger.hh
+  BigIntegerLibrary.hh
+  BigIntegerUtils.cc
+  BigIntegerUtils.hh
+  BigUnsigned.cc
+  BigUnsigned.hh
+  BigUnsignedInABase.cc
+  BigUnsignedInABase.hh
+	NumberlikeArray.hh
+)

libs/dlfcn-win32/CMakeLists.txt

@@ -0,0 +1,9 @@
+if (WIN32 OR MSYS)
+	add_library(dlfcn STATIC EXCLUDE_FROM_ALL
+		dlfcn.cc
+		dlfcn.h
+	)
+	target_include_directories(dlfcn PUBLIC
+		${CMAKE_CURRENT_SOURCE_DIR}
+	)
+endif()

libs/ezsat/CMakeLists.txt

@@ -0,0 +1,16 @@
+yosys_core(ezsat
+	ezsat.cc
+	ezsat.h
+	ezminisat.cc
+	ezminisat.h
+	ezcmdline.cc
+	ezcmdline.h
+	REQUIRES
+		minisat
+	DATA_DIR
+		include/libs/ezsat
+	DATA_FILES
+		ezsat.h
+		ezminisat.h
+		ezcmdline.h
+)

libs/ezsat/ezcmdline.cc

@@ -9,7 +9,7 @@ ezCmdlineSAT::~ezCmdlineSAT() {}
 
 bool ezCmdlineSAT::solver(const std::vector<int> &modelExpressions, std::vector<bool> &modelValues, const std::vector<int> &assumptions)
 {
-#if !defined(YOSYS_DISABLE_SPAWN)
+#if defined(YOSYS_ENABLE_SPAWN)
 	const std::string tempdir_name = Yosys::make_temp_dir(Yosys::get_base_tmpdir() + "/yosys-sat-XXXXXX");
 	const std::string cnf_filename = Yosys::stringf("%s/problem.cnf", tempdir_name.c_str());
 	const std::string sat_command = Yosys::stringf("%s %s", command.c_str(), cnf_filename.c_str());

libs/flex/FlexLexer.h

@@ -0,0 +1,220 @@
+// -*-C++-*-
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+// by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+
+//  1. Redistributions of source code must retain the above copyright
+//  notice, this list of conditions and the following disclaimer.
+//  2. Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+
+//  Neither the name of the University nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+
+//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//      #undef yyFlexLexer
+//      #define yyFlexLexer xxFlexLexer
+//      #include <FlexLexer.h>
+//
+//      #undef yyFlexLexer
+//      #define yyFlexLexer zzFlexLexer
+//      #include <FlexLexer.h>
+//      ...
+
+#ifndef __FLEX_LEXER_H
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+
+#include <iostream>
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer
+{
+public:
+  virtual ~FlexLexer()        { }
+
+  const char* YYText() const  { return yytext; }
+  int YYLeng()        const   { return yyleng; }
+
+  virtual void
+  yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
+  virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
+  virtual void yyrestart( std::istream* s ) = 0;
+  virtual void yyrestart( std::istream& s ) = 0;
+
+  virtual int yylex() = 0;
+
+  // Call yylex with new input/output sources.
+  int yylex( std::istream& new_in, std::ostream& new_out )
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  int yylex( std::istream* new_in, std::ostream* new_out = 0)
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  // Switch to new input/output streams.  A nil stream pointer
+  // indicates "keep the current one".
+  virtual void switch_streams( std::istream* new_in,
+                               std::ostream* new_out ) = 0;
+  virtual void switch_streams( std::istream& new_in,
+                               std::ostream& new_out ) = 0;
+
+  int lineno() const          { return yylineno; }
+
+  int debug() const           { return yy_flex_debug; }
+  void set_debug( int flag )  { yy_flex_debug = flag; }
+
+protected:
+  char* yytext;
+  int yyleng;
+  int yylineno;       // only maintained if you use %option yylineno
+  int yy_flex_debug;  // only has effect with -d or "%option debug"
+};
+
+}
+#endif // FLEXLEXER_H
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex manual.
+# define yyFlexLexerOnce
+
+extern "C++" {
+
+class yyFlexLexer : public FlexLexer {
+public:
+  // arg_yyin and arg_yyout default to the cin and cout, but we
+  // only make that assignment when initializing in yylex().
+  yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
+  yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
+private:
+  void ctor_common();
+
+public:
+
+  virtual ~yyFlexLexer();
+
+  void yy_switch_to_buffer( yy_buffer_state* new_buffer );
+  yy_buffer_state* yy_create_buffer( std::istream* s, int size );
+  yy_buffer_state* yy_create_buffer( std::istream& s, int size );
+  void yy_delete_buffer( yy_buffer_state* b );
+  void yyrestart( std::istream* s );
+  void yyrestart( std::istream& s );
+
+  void yypush_buffer_state( yy_buffer_state* new_buffer );
+  void yypop_buffer_state();
+
+  virtual int yylex();
+  virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
+  virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
+  virtual int yywrap();
+
+protected:
+  virtual int LexerInput( char* buf, int max_size );
+  virtual void LexerOutput( const char* buf, int size );
+  virtual void LexerError( const char* msg );
+
+  void yyunput( int c, char* buf_ptr );
+  int yyinput();
+
+  void yy_load_buffer_state();
+  void yy_init_buffer( yy_buffer_state* b, std::istream& s );
+  void yy_flush_buffer( yy_buffer_state* b );
+
+  int yy_start_stack_ptr;
+  int yy_start_stack_depth;
+  int* yy_start_stack;
+
+  void yy_push_state( int new_state );
+  void yy_pop_state();
+  int yy_top_state();
+
+  yy_state_type yy_get_previous_state();
+  yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+  int yy_get_next_buffer();
+
+  std::istream yyin;  // input source for default LexerInput
+  std::ostream yyout; // output sink for default LexerOutput
+
+  // yy_hold_char holds the character lost when yytext is formed.
+  char yy_hold_char;
+
+  // Number of characters read into yy_ch_buf.
+  int yy_n_chars;
+
+  // Points to current character in buffer.
+  char* yy_c_buf_p;
+
+  int yy_init;                // whether we need to initialize
+  int yy_start;               // start state number
+
+  // Flag which is used to allow yywrap()'s to do buffer switches
+  // instead of setting up a fresh yyin.  A bit of a hack ...
+  int yy_did_buffer_switch_on_eof;
+
+
+  size_t yy_buffer_stack_top; /**< index of top of stack. */
+  size_t yy_buffer_stack_max; /**< capacity of stack. */
+  yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+  void yyensure_buffer_stack(void);
+
+  // The following are not always needed, but may be depending
+  // on use of certain flex features (like REJECT or yymore()).
+
+  yy_state_type yy_last_accepting_state;
+  char* yy_last_accepting_cpos;
+
+  yy_state_type* yy_state_buf;
+  yy_state_type* yy_state_ptr;
+
+  char* yy_full_match;
+  int* yy_full_state;
+  int yy_full_lp;
+
+  int yy_lp;
+  int yy_looking_for_trail_begin;
+
+  int yy_more_flag;
+  int yy_more_len;
+  int yy_more_offset;
+  int yy_prev_more_offset;
+};
+
+}
+
+#endif // yyFlexLexer || ! yyFlexLexerOnce

libs/flex/README.txt

@@ -0,0 +1,2 @@
+This is a vendored copy of FlexLexer.h that is used if flex include directories are not found
+on the system. It is provided because not having it is making cross-compilation drastically harder.

libs/fst/CMakeLists.txt

@@ -0,0 +1,18 @@
+yosys_core(fst
+	config.h
+	fastlz.cc
+	fastlz.h
+	fstapi.cc
+	fstapi.h
+	fst_win_unistd.h
+	lz4.cc
+	lz4.h
+	LIBRARIES
+		$<${YOSYS_ENABLE_ZLIB}:PkgConfig::zlib>
+	DATA_DIR
+		include/libs/fst
+	DATA_FILES
+		fstapi.h
+	ENABLE_IF
+		YOSYS_ENABLE_ZLIB
+)

libs/json11/CMakeLists.txt

@@ -0,0 +1,8 @@
+yosys_core(json11
+  json11.cpp
+	json11.hpp
+	DATA_DIR
+		include/libs/json11
+	DATA_FILES
+		json11.hpp
+)

libs/minisat/CMakeLists.txt

@@ -0,0 +1,24 @@
+yosys_core(minisat
+  Alg.h
+  Alloc.h
+  Dimacs.h
+  Heap.h
+  IntMap.h
+  IntTypes.h
+  Map.h
+  Options.cc
+  Options.h
+  ParseUtils.h
+  Queue.h
+  Rnd.h
+  SimpSolver.cc
+  SimpSolver.h
+  Solver.cc
+  Solver.h
+  SolverTypes.h
+  Sort.h
+  System.cc
+  System.h
+  Vec.h
+  XAlloc.h
+)

libs/sha1/CMakeLists.txt

@@ -0,0 +1,8 @@
+yosys_core(sha1
+	sha1.cpp
+	sha1.h
+	DATA_DIR
+		include/libs/sha1
+	DATA_FILES
+		sha1.h
+)

libs/subcircuit/CMakeLists.txt

@@ -0,0 +1,4 @@
+yosys_core(subcircuit
+	subcircuit.cc
+	subcircuit.h
+)