ROSE Docker Build

Build the ROSE source-to-source compiler in an isolated Docker container.

Why Docker?

ROSE requires GCC 7-10. Modern systems have GCC 11+, causing build failures. Docker provides: - Correct GCC version (9.x recommended) - All dependencies pre-installed - Reproducible builds - Edit on host, build in container

Quick Start (Autotools)

# 1. Clone ROSE
git clone [email protected]:rose-compiler/rose.git
cd rose && git checkout weekly

# 2. Create Docker environment
mkdir ../rose-docker && cd ../rose-docker

# 3. Build and run container (see Dockerfile below)
docker build -t rose-dev .
docker run -d --name rose-dev -v $(pwd)/../rose:/rose/src rose-dev

# 4. Build ROSE inside container
docker exec rose-dev bash -c 'cd /rose/src && ./build'
docker exec rose-dev bash -c 'mkdir -p /rose/build && cd /rose/build && 
  /rose/src/configure --prefix=/rose/install 
    --enable-languages=c,c++ 
    --with-boost=/usr 
    --with-boost-libdir=/usr/lib/x86_64-linux-gnu 
    --disable-binary-analysis 
    --disable-java'
docker exec rose-dev bash -c 'cd /rose/build && make core -j$(nproc)'
docker exec rose-dev bash -c 'cd /rose/build && make install-core'

Quick Start (CMake)

CMake builds require CMake 4.x (3.16 fails at ROSETTA generation).

# 1. Clone ROSE
git clone [email protected]:rose-compiler/rose.git
cd rose && git checkout weekly

# 2. Create Docker environment and build container
mkdir ../rose-docker && cd ../rose-docker
docker build -t rose-dev -f Dockerfile.cmake .
docker run -d --name rose-cmake -v $(pwd)/../rose:/rose/src:ro rose-dev

# 3. Configure with CMake
docker exec -w /rose/build rose-cmake cmake /rose/src 
  -DCMAKE_INSTALL_PREFIX=/rose/install 
  -DENABLE_C=ON 
  -DENABLE_TESTS=OFF 
  -DCMAKE_BUILD_TYPE=Release

# 4. Build (use -j4 to avoid OOM on 16GB systems)
docker exec -w /rose/build rose-cmake make -j4

# 5. Test
docker exec rose-cmake /rose/build/bin/rose-compiler --version

CMake Options

Option	Description
ENABLE_C=ON	Enable C/C++ analysis (uses EDG frontend)
ENABLE_BINARY_ANALYSIS=ON	Enable binary analysis (no EDG needed)
ENABLE_TESTS=OFF	Skip test compilation (faster build)
CMAKE_BUILD_TYPE=Release	Optimized build

CMake vs Autotools

Feature	Autotools	CMake
Stability	✅ Mature	⚠️ Newer
C/C++ analysis	✅ Works	✅ Works (with fixes)
Build target	make core	make (full build)
Incremental builds	Slower	Faster
IDE integration	Limited	Excellent

Dockerfiles

Dockerfile (Autotools)

FROM ubuntu:20.04
ENV DEBIAN_FRONTEND=noninteractive
ENV TZ=America/Los_Angeles

RUN apt-get update && apt-get install -y 
    build-essential g++ gcc gfortran 
    automake autoconf libtool flex bison 
    libboost-all-dev libxml2-dev 
    git wget curl vim 
    && rm -rf /var/lib/apt/lists/*

RUN useradd -m -s /bin/bash developer
RUN mkdir -p /rose/src /rose/build /rose/install && chown -R developer:developer /rose
USER developer
WORKDIR /rose
CMD ["tail", "-f", "/dev/null"]

Dockerfile.cmake (CMake)

FROM ubuntu:20.04
ENV DEBIAN_FRONTEND=noninteractive
ENV TZ=America/Los_Angeles

# Install build dependencies
RUN apt-get update && apt-get install -y 
    build-essential g++ gcc gfortran 
    flex bison 
    libboost-all-dev libxml2-dev libreadline-dev 
    zlib1g-dev libsqlite3-dev libpq-dev libyaml-dev 
    libgmp-dev libmpc-dev libmpfr-dev 
    git wget curl vim 
    gnupg software-properties-common 
    && rm -rf /var/lib/apt/lists/*

# Install CMake 4.x from Kitware (Ubuntu 20.04 has 3.16 which is too old)
RUN wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | apt-key add - 
    && echo 'deb https://apt.kitware.com/ubuntu/ focal main' > /etc/apt/sources.list.d/kitware.list 
    && apt-get update && apt-get install -y cmake 
    && rm -rf /var/lib/apt/lists/*

RUN useradd -m -s /bin/bash developer
RUN mkdir -p /rose/src /rose/build /rose/install && chown -R developer:developer /rose
USER developer
WORKDIR /rose
CMD ["tail", "-f", "/dev/null"]

EDG Binary Handling

EDG (C++ frontend) binaries are required for C/C++ analysis. The build checks:

Autotools

1. Build directory for existing tarball
2. Source tree at src/frontend/CxxFrontend/roseBinaryEDG-*.tar.gz
3. Network download from edg-binaries.rosecompiler.org

CMake

1. Source tree at src/frontend/CxxFrontend/roseBinaryEDG-*.tar.gz (auto-detected)
2. Extracts matching tarball based on GCC version at build time
3. Links libroseEDG.a to librose.so automatically

If server is down, ensure source tree has EDG binaries (included in weekly branch).

Common Commands

Autotools

# Rebuild after source changes
docker exec rose-dev bash -c 'cd /rose/build && make core -j8'

# Install
docker exec rose-dev bash -c 'cd /rose/build && make install-core'

CMake

# Rebuild after source changes  
docker exec -w /rose/build rose-cmake make -j4

# Install
docker exec -w /rose/build rose-cmake make install

Both

# Test ROSE compiler
docker exec rose-dev /rose/install/bin/rose-compiler --version
docker exec rose-cmake /rose/build/bin/rose-compiler --version

# Source-to-source test
docker exec rose-dev bash -c 'echo "int main(){return 0;}" > /tmp/test.c && 
  /rose/install/bin/rose-compiler -c /tmp/test.c && cat rose_test.c'

# Enter container shell
docker exec -it rose-dev bash
docker exec -it rose-cmake bash

Build Time

Build System	First Build	Incremental
Autotools (make core -j8)	~60-90 min	seconds-minutes
CMake (make -j4)	~35 min	seconds-minutes

• librose.so: ~200 MB (CMake) to ~1.3 GB (autotools with debug)
• Memory: Use -j4 on 16GB systems to avoid OOM

Troubleshooting

Issue	Solution
EDG download fails	Use weekly branch (has EDG binaries in source tree)
CMake: ROSETTA fails	Upgrade to CMake 4.x
CMake: EDG link errors	Ensure using latest CMake fixes (PR #250)
CMake: quadmath errors	Add -lquadmath or use latest fixes
Permission denied	Check volume mount permissions
Out of memory	Reduce -j parallelism
Boost not found	Verify boost paths in configure/cmake

Testing with Sample Code

# Create factorial test
cat << 'EOF' | docker exec -i rose-cmake tee /tmp/factorial.cpp
#include <iostream>
int factorial(int n) { return n <= 1 ? 1 : n * factorial(n-1); }
int main() {
    for(int i = 0; i <= 10; i++)
        std::cout << "factorial(" << i << ") = " << factorial(i) << std::endl;
    return 0;
}
EOF

# Run through ROSE (source-to-source transformation)
docker exec -w /tmp rose-cmake /rose/build/bin/rose-compiler factorial.cpp

# Compile and run the transformed code
docker exec -w /tmp rose-cmake g++ rose_factorial.cpp -o factorial_test
docker exec -w /tmp rose-cmake ./factorial_test

Expected output:

factorial(0) = 1
factorial(1) = 1
...
factorial(10) = 3628800