The simplest way to hide a function is to declare it static inside the C source file. A static function is only visible within that single .c file. No other file — not even another .c file in the same library — can call it directly.

Bonus effect of static: When a symbol is static, all calls to it within the same source file are bound at compile time. This means they cannot be interposed at runtime by a symbol with the same name in another library — a useful performance and correctness benefit.

The static keyword limits a function to a single file. But what if you need a function to be shared across multiple .c files within your library, but still hidden from the outside world?

GCC’s visibility attribute handles this case. There are two main values:

/* mylib.c — part of mylib.so */
#include <stdio.h>
#include <string.h>

/* PRIVATE: only used internally, not part of the public API */
static int validate_input(const char *s) {
    if (s == NULL || strlen(s) == 0) return 0;
    return 1;
}

/* PUBLIC: this is the API that users of the library call */
void mylib_process(const char *input) {
    if (!validate_input(input)) {
        printf("Invalid input!\n");
        return;
    }
    printf("Processing: %s\n", input);
}

# Build the shared library
gcc -g -fPIC -c -Wall mylib.c
gcc -g -shared -o mylib.so mylib.o

# Check exported symbols — validate_input should NOT appear
readelf --dyn-syms mylib.so | grep -E "validate|process"
# Expected: only mylib_process is GLOBAL, validate_input is LOCAL

/* internal.h — shared header for library internals */
#ifndef INTERNAL_H
#define INTERNAL_H

/* This function is available to all .c files in the library
   but is NOT exported to external users */
__attribute__((visibility("hidden")))
void internal_log(const char *msg);

#endif

/* internal.c — defines the hidden helper */
#include <stdio.h>
#include "internal.h"

__attribute__((visibility("hidden")))
void internal_log(const char *msg) {
    printf("[LIB INTERNAL] %s\n", msg);
}

/* api.c — defines the public API, uses the hidden helper */
#include <stdio.h>
#include "internal.h"

/* Mark as default visibility = publicly exported */
__attribute__((visibility("default")))
void api_do_work(const char *data) {
    internal_log("api_do_work called");   /* can call internal helper */
    printf("Working on: %s\n", data);
}

__attribute__((visibility("default")))
void api_cleanup(void) {
    internal_log("api_cleanup called");
    printf("Cleanup done.\n");
}

# Build the library from two source files
gcc -g -fPIC -c -Wall internal.c api.c
gcc -g -shared -o libwork.so internal.o api.o

# Check symbol visibility
readelf --dyn-syms libwork.so
# api_do_work   → GLOBAL DEFAULT  (exported ✅)
# api_cleanup   → GLOBAL DEFAULT  (exported ✅)
# internal_log  → LOCAL  (hidden ❌ from outside)

A very clean approach is to compile with -fvisibility=hidden to make ALL symbols hidden by default, then explicitly mark only the public API with visibility("default"). This way you don’t have to tag every internal function — they’re hidden automatically.

/* libmath.h — public API header */
#ifndef LIBMATH_H
#define LIBMATH_H

/* Only these functions are publicly exported */
#define PUBLIC_API __attribute__((visibility("default")))

PUBLIC_API int lib_add(int a, int b);
PUBLIC_API int lib_multiply(int a, int b);

#endif

/* libmath.c */
#include <stdio.h>
#include "libmath.h"

/* Internal helper — NOT tagged, so hidden by -fvisibility=hidden */
static int clamp(int val, int min, int max) {
    if (val < min) return min;
    if (val > max) return max;
    return val;
}

/* These are tagged PUBLIC_API = visible outside */
PUBLIC_API int lib_add(int a, int b) {
    return a + b;
}

PUBLIC_API int lib_multiply(int a, int b) {
    /* internal call to clamp — fine within the library */
    a = clamp(a, -1000, 1000);
    b = clamp(b, -1000, 1000);
    return a * b;
}

# -fvisibility=hidden makes all symbols hidden by default
gcc -g -fPIC -c -Wall -fvisibility=hidden libmath.c
gcc -g -shared -o libmath.so libmath.o

readelf --dyn-syms libmath.so
# lib_add      → GLOBAL DEFAULT (exported, tagged with PUBLIC_API)
# lib_multiply → GLOBAL DEFAULT (exported, tagged with PUBLIC_API)
# clamp        → not in dynamic table (static = truly private)