When a program is executed, the dynamic linker searches for shared libraries in this exact order:

The -rpath option is passed to the linker via gcc’s -Wl, mechanism:

# Basic: embed /home/mtk/pdir into the rpath of prog
gcc -g -Wall \
    -Wl,-rpath,/home/mtk/pdir \
    -o prog prog.c libdemo.so

# The dynamic linker will search /home/mtk/pdir at runtime

You can specify multiple rpath directories in two ways:

# Method 1: Multiple -rpath options (each adds to the list)
gcc -o prog prog.c \
    -Wl,-rpath,/opt/myapp/lib \
    -Wl,-rpath,/usr/local/vendor/lib \
    -ldemo

# Method 2: Colon-separated list in one -rpath option
gcc -o prog prog.c \
    -Wl,-rpath,/opt/myapp/lib:/usr/local/vendor/lib \
    -ldemo

# Verify what got embedded:
objdump -p prog | grep RPATH
# Output: RPATH /opt/myapp/lib:/usr/local/vendor/lib

Instead of specifying -rpath on the gcc command line, you can set the LD_RUN_PATH environment variable before building:

# Set LD_RUN_PATH before the build command
export LD_RUN_PATH=/home/mtk/pdir:/opt/myapp/lib

# Now build without -rpath; LD_RUN_PATH is used instead
gcc -g -Wall -o prog prog.c -L/home/mtk/pdir -ldemo

# Verify it was embedded
objdump -p prog | grep RPATH
# Output: RPATH /home/mtk/pdir:/opt/myapp/lib

#!/bin/bash
# rpath_demo.sh — demonstrates -rpath for non-standard library location

set -e
WORKDIR=/tmp/rpath_demo
mkdir -p $WORKDIR/mylib $WORKDIR/myapp
cd $WORKDIR

# ---- Create the shared library source ----
cat > mylib/myutils.c << 'EOF'
#include <stdio.h>

void say_hello(const char *who) {
    printf("Hello from myutils library, %s!\n", who);
}

int add_numbers(int a, int b) {
    return a + b;
}
EOF

# ---- Create the application source ----
cat > myapp/main.c << 'EOF'
#include <stdio.h>

void say_hello(const char *who);
int add_numbers(int a, int b);

int main(void) {
    say_hello("EmbeddedPathashala");
    int result = add_numbers(10, 32);
    printf("10 + 32 = %d\n", result);
    return 0;
}
EOF

echo "=== Building shared library in non-standard dir: $WORKDIR/mylib ==="
cd $WORKDIR/mylib
gcc -g -c -fPIC -Wall myutils.c
gcc -g -shared -Wl,-soname,libmyutils.so.1 \
    -o libmyutils.so.1.0.0 myutils.o
ln -sf libmyutils.so.1.0.0 libmyutils.so.1
ln -sf libmyutils.so.1 libmyutils.so

echo "=== Building application with -rpath embedded ==="
cd $WORKDIR/myapp
gcc -g -Wall \
    -Wl,-rpath,$WORKDIR/mylib \
    -L$WORKDIR/mylib \
    -o myapp main.c \
    -lmyutils

echo ""
echo "=== Inspecting rpath embedded in myapp ==="
objdump -p myapp | grep RPATH
# Expected: RPATH /tmp/rpath_demo/mylib

echo ""
echo "=== ldd shows the library is found via rpath ==="
ldd myapp

echo ""
echo "=== Running myapp (no LD_LIBRARY_PATH needed!) ==="
./myapp

#!/bin/bash
# compare_methods.sh — show difference between LD_LIBRARY_PATH and rpath

WORKDIR=/tmp/compare_demo
mkdir -p $WORKDIR/lib $WORKDIR/bin
cd $WORKDIR

# Assume libdemo.so is already built in $WORKDIR/lib
# Build with rpath:
echo "=== Build WITH rpath ==="
gcc -o bin/prog_rpath main.c \
    -Wl,-rpath,$WORKDIR/lib \
    -L$WORKDIR/lib \
    -ldemo
echo "prog_rpath rpath:"
objdump -p bin/prog_rpath | grep RPATH

# Build WITHOUT rpath:
echo ""
echo "=== Build WITHOUT rpath ==="
gcc -o bin/prog_norpath main.c \
    -L$WORKDIR/lib \
    -ldemo
echo "prog_norpath rpath (should be empty):"
objdump -p bin/prog_norpath | grep RPATH || echo "  (no RPATH embedded)"

echo ""
echo "=== Running prog_rpath (works without LD_LIBRARY_PATH) ==="
bin/prog_rpath && echo "Success!" || echo "Failed"

echo ""
echo "=== Running prog_norpath WITHOUT LD_LIBRARY_PATH (should fail) ==="
bin/prog_norpath 2>&1 || echo "Expected failure: library not found"

echo ""
echo "=== Running prog_norpath WITH LD_LIBRARY_PATH (works) ==="
LD_LIBRARY_PATH=$WORKDIR/lib bin/prog_norpath && echo "Success!"

echo ""
echo "=== NOTE: LD_LIBRARY_PATH overrides rpath with DT_RUNPATH, ==="
echo "=== but NOT with DT_RPATH (old ELF tag). ==="

#!/bin/bash
# ld_run_path_demo.sh — using LD_RUN_PATH as alternative to -rpath

WORKDIR=/tmp/ldrunpath_demo
mkdir -p $WORKDIR/lib $WORKDIR/app
cd $WORKDIR

# Suppose libfoo is in /opt/locallibs/lib
LIBDIR=/opt/locallibs/lib
mkdir -p $LIBDIR

# Build the library
cat > /tmp/foo.c << 'EOF'
#include <stdio.h>
void foo_init(void) { printf("foo library initialized\n"); }
EOF
gcc -shared -fPIC -o $LIBDIR/libfoo.so /tmp/foo.c

# Build using LD_RUN_PATH (no -rpath on command line)
echo "=== Method 1: LD_RUN_PATH during build ==="
export LD_RUN_PATH=$LIBDIR
gcc -o app/prog_ldrunpath main.c -L$LIBDIR -lfoo
objdump -p app/prog_ldrunpath | grep RPATH
unset LD_RUN_PATH

# Build using -rpath directly (overrides LD_RUN_PATH)
echo ""
echo "=== Method 2: -rpath on command line ==="
export LD_RUN_PATH=/some/other/path   # this will be IGNORED
gcc -o app/prog_rpath main.c \
    -Wl,-rpath,$LIBDIR \
    -L$LIBDIR -lfoo
objdump -p app/prog_rpath | grep RPATH
# Shows $LIBDIR, NOT /some/other/path — -rpath wins
unset LD_RUN_PATH