The simplest way to hide a symbol is to mark it static. A static function or variable is visible only within the single source file where it is defined.

/* mylib_internal.c */

/* This function is VISIBLE externally — exported by default */
void public_api(void) {
    /* calls the internal helper */
    internal_helper();
}

/* This function is HIDDEN — only visible within this .c file */
static void internal_helper(void) {
    /* implementation detail */
}

/* This variable is HIDDEN — file-local only */
static int internal_counter = 0;

Limitation: static only hides from other .c files. If your shared library is built from multiple .c files and you want a helper function accessible from several of those files but hidden from outside the library — static does not help. You need the visibility attribute instead.

GCC provides a __attribute__((visibility(...))) declaration that controls symbol visibility more precisely than static.

The two main values are:

/* "default" visibility — exported, visible outside the library (this is the default) */
void __attribute__((visibility("default"))) public_function(void) {
    /* ... */
}

/* "hidden" visibility — NOT exported, not visible outside the library
   but CAN be used by other .c files within the same shared library */
void __attribute__((visibility("hidden"))) internal_helper(void) {
    /* ... */
}

Practical usage — define macros for cleaner code:

/* visibility_macros.h */
#if defined(__GNUC__) && __GNUC__ >= 4
    #define LIB_PUBLIC  __attribute__((visibility("default")))
    #define LIB_PRIVATE __attribute__((visibility("hidden")))
#else
    #define LIB_PUBLIC
    #define LIB_PRIVATE
#endif

/* math_lib.c — uses visibility macros */
#include "visibility_macros.h"

/* Public API — visible to callers of the library */
LIB_PUBLIC double fast_sqrt(double x);
LIB_PUBLIC double fast_pow(double base, double exp);

/* Internal helpers — hidden from outside, shared within library */
LIB_PRIVATE double newton_step(double x, double guess);
LIB_PRIVATE double log_approx(double x);

Alternatively, use the compiler flag to hide everything by default and only selectively expose what you want:

# Hide everything by default — requires explicit "default" for each public symbol
gcc -fvisibility=hidden -fPIC -shared -o mylib.so mylib.c

/* badlib.c — no visibility control — everything exported (bad practice) */
#include <stdio.h>

/* Internal helper — should NOT be public but will be */
void internal_helper(void) {
    printf("[internal] helper running\n");
}

/* Another internal function */
int compute_internal(int x) {
    return x * x;
}

/* Intended public API */
void public_compute(int x) {
    int result = compute_internal(x);
    internal_helper();
    printf("Result: %d\n", result);
}

gcc -fPIC -shared -o badlib.so badlib.c
readelf --syms --use-dynamic badlib.so | grep -v UND

# Output (all three symbols are GLOBAL — visible to everyone!):
#  ... FUNC GLOBAL DEFAULT ... internal_helper
#  ... FUNC GLOBAL DEFAULT ... compute_internal
#  ... FUNC GLOBAL DEFAULT ... public_compute

/* goodlib.c — proper visibility control */
#include <stdio.h>

/* Mark internal functions hidden */
__attribute__((visibility("hidden")))
static void internal_helper(void) {
    printf("[internal] helper running\n");
}

__attribute__((visibility("hidden")))
static int compute_internal(int x) {
    return x * x;
}

/* Public API — explicitly default visibility */
__attribute__((visibility("default")))
void public_compute(int x) {
    int result = compute_internal(x);
    internal_helper();
    printf("Result: %d\n", result);
}

gcc -fPIC -shared -o goodlib.so goodlib.c
readelf --syms --use-dynamic goodlib.so | grep -v UND

# Output (only the intended public function is visible!):
#  ... FUNC GLOBAL DEFAULT ... public_compute
#
# internal_helper and compute_internal do NOT appear in the dynamic
# symbol table — they are hidden

/* api.h — public API header for our library */
#define API_EXPORT __attribute__((visibility("default")))

API_EXPORT void  lib_init(void);
API_EXPORT int   lib_process(const char *data, int len);
API_EXPORT void  lib_cleanup(void);

/* lib.c — implementation; all symbols hidden unless marked API_EXPORT */
#include <stdio.h>
#include <string.h>
#include "api.h"

/* Private state — hidden */
static int initialized = 0;
static int total_processed = 0;

/* Private helpers — hidden */
static int validate_input(const char *data, int len) {
    return data != NULL && len > 0;
}

static void log_internal(const char *msg) {
    fprintf(stderr, "[lib internal] %s\n", msg);
}

/* Public functions — marked API_EXPORT in api.h */
void lib_init(void) {
    if (!initialized) {
        log_internal("initializing");
        initialized = 1;
    }
}

int lib_process(const char *data, int len) {
    if (!initialized) { log_internal("not initialized!"); return -1; }
    if (!validate_input(data, len)) return -1;
    total_processed += len;
    printf("Processed %d bytes (total: %d)\n", len, total_processed);
    return len;
}

void lib_cleanup(void) {
    log_internal("cleanup");
    initialized = 0;
    total_processed = 0;
}

# Build with -fvisibility=hidden: everything is hidden UNLESS marked API_EXPORT
gcc -fPIC -fvisibility=hidden -shared -o lib.so lib.c

# Check exports — only lib_init, lib_process, lib_cleanup should appear:
nm -D lib.so | grep ' T '
# T lib_cleanup
# T lib_init
# T lib_process
# (validate_input, log_internal, initialized, total_processed NOT listed)