GCCGO(1)

📦
version 16.2.1+r23+gd564253eb6c8 · 14 versions
, in arch rolling

👑 gccgo — the GCC-based compiler for the Go language 👑

welcome to the gccgo(1) page bestie, straight from the GNU squad 💖

NAME

gccgo — a GCC-based compiler for the Go language 🐹✨

SYNOPSIS

gccgo [-c|-S]
      [-g] [-pg] [-Olevel]
      [-Idir...] [-Ldir...]
      [-o outfile] infile...
ngl this is only the most useful options — the rest are down below. keep scrolling 💅

DESCRIPTION

okay so here's the tea: the gccgo command is a frontend to gcc, and it supports many of the same options. but this manual only documents the options specific to gccgo, so don't come for me about the shared ones. 🎀

You can use gccgo to compile Go source code into an object file, to link a collection of object files together, or to do both — one after the other, in sequence. versatile queen 👑

Go source code gets compiled as packages. A package is made up of one or more Go source files. Every file in a single package has to be compiled together, which means you pass all the files as arguments to gccgo. And a single invocation of gccgo can only compile a single package — no multitasking, she's focused. 🧚

One Go package can "import" a different Go package. That imported package must have already been compiled — gccgo reads the import data directly from the compiled package. So when you later link this package, the compiled form of the imported one has to be included in the link command. don't forget it fr fr 📎

Go programs must generally be compiled with debugging information, and -g1 is the default, as described below. Stripping a Go program will generally cause it to misbehave or fail. like, do not do that. it's giving chaos 💀

✨ OPTIONS ✨

  • -Idir — tell it which directory to search when it's hunting for an import package at compile time. 📁
  • -Ldir — when linking, this specifies a library search directory, exactly like with gcc.
  • -fgo-pkgpath=string — sets the package path to use. This sets the value returned by the PkgPath method of reflect.Type objects. It's also used for the names of globally visible symbols. The argument here should normally be the string you'll use to import this package after it's been installed — in other words, a pathname within the directories you specified with the -I option. 👑
  • -fgo-prefix=string — an alternative to -fgo-pkgpath. The argument gets combined with the package name from the source file to produce the package path. If -fgo-pkgpath is used, -fgo-prefix will be ignored.

So here's why this matters: Go lets a single program include more than one package with the same name in the "package" clause in the source file — though obviously those two packages have to be imported using different pathnames. For that to work with gccgo, you must specify either -fgo-pkgpath or -fgo-prefix when compiling a package.

Also: using either -fgo-pkgpath or -fgo-prefix disables the special treatment of the "main" package and lets that package be imported like any other. slay 🫶

  • -fgo-relative-import-path=dir — a relative import is an import that starts with ./ or ../. If you use this option, gccgo will use dir as a prefix for the relative import while searching for it. 🌈
  • -frequire-return-statement
  • -fno-require-return-statement — by default gccgo warns about functions that have one or more return parameters but lack an explicit "return" statement. That warning can be turned off with -fno-require-return-statement. 🙈
  • -fgo-check-divide-zero — adds explicit checks for division by zero. In Go, a division (or modulo) by zero causes a panic. On Unix systems this gets detected in the runtime by catching the "SIGFPE" signal. But some processors, like PowerPC, don't generate a SIGFPE on division by zero, and some runtimes don't generate a signal that can be caught at all. On those systems, you can use this option. Or you can remove the checks with -fno-go-check-divide-zero. This option is currently on by default, but in the future it may be off by default on systems that don't need it. 💜
  • -fgo-check-divide-overflow — adds explicit checks for division overflow. For example, division overflow happens when computing "INT_MIN / -1". In Go this should be wrapped, producing "INT_MIN". Some processors, like x86, generate a trap on division overflow — on those systems, this option may be used. Or the checks can be removed with -fno-go-check-divide-overflow. This option is currently on by default, but in the future it may be off by default on systems that don't require it. ⭐
  • -fno-go-optimize-allocs — disables escape analysis, which tries to allocate objects on the stack instead of the heap. 🍓
  • -fgo-debug-escapen — outputs escape analysis debugging information. Larger values of n generate more information.
  • -fgo-debug-escape-hash=n — a hash value used to debug escape analysis. n is a binary string. This runs escape analysis only on functions whose names hash to values matching the given suffix n. Perfect for binary searching across functions to uncover escape analysis bugs 🔥
  • -fgo-debug-optimization — outputs optimization diagnostics. 🔍
  • -fgo-c-header=file — writes top-level named Go struct definitions to file as C code. This is used when compiling the runtime package. 🎀
  • -fgo-compiling-runtime — applies special rules for compiling the runtime package. Implicit memory allocation is forbidden. Some additional compiler directives are supported. 💅
  • -fgo-embedcfg=file — identifies a JSON file used to map patterns used with special "//go:embed" comments to the files named by those patterns. The JSON file should have two components: "Patterns" maps each pattern to a list of file names, and "Files" maps each file name to a full path to the file. This option is intended for use by the go command to implement "//go:embed". 📦
  • -fgo-importcfg=file — identifies a file that provides mappings for import package paths found in the Go source files. The file can contain two commands: "importpath" to rename import paths for vendoring, and "packagefile" to map from package path to files containing export data. This option is intended for use by the go command. 🗺️
  • -g — this is the standard gcc option, but it gets a shoutout here because by default gccgo turns on debugging information generation with the equivalent of the standard option -g1. Why? Because Go programs require debugging information to be available in order to get backtrace information. An explicit -g0 may be used to disable the generation of debugging information — but in that case, certain standard library functions, such as "runtime.Callers", will not operate correctly. 😭 choose wisely bestie

SEE ALSO

gpl(7), gfdl(7), fsf-funding(7), gcc(1), and the Info entries for gccgo and gcc. 🦋

Copyright (c) 2010-2026 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the man page gfdl(7).

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.

and that's the whole page, bestie 💖 this one's from gcc-16, dated 2026-08-10 — iconic, no cap, periodt 👑✨

📦 where this page comes from