Rose Docker Build

# 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)

```bash # 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).

```bash # 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)

```dockerfile 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)

```dockerfile 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 ```bash # 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 ```bash # Rebuild after source changes docker exec -w /rose/build rose-cmake make -j4

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

Both ```bash # 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

```bash # 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 ```