Can local and register variables be declared extern?

Local variables can be declared extern in some cases

Let's read the C99 N1256 standard draft.

The standard calls "local variables" as having "block scope".

6.7.1/5 "Storage-class specifiers" says:

The declaration of an identifier for a function that has block scope shall have no explicit storage-class specifier other than extern.

Then for what it means to add extern to a local variable, 6.2.2/4 "Linkages of identifiers" says:

For an identifier declared with the storage-class specifier extern in a scope in which a prior declaration of that identifier is visible, if the prior declaration specifies internal or external linkage, the linkage of the identifier at the later declaration is the same as the linkage specified at the prior declaration. If no prior declaration is visible, or if the prior declaration specifies no linkage, then the identifier has external linkage.

Lets break down those cases.

no prior declaration

void f() {
    extern int i;
}

is the same as:

extern int i;
void f() {}

except that the declaration is only visible inside f.

This is because i has no prior declaration visible. So i has external linkage (the same linkage as global variables).

prior declaration specifies no linkage

int i;
void f() {
    extern int i;
}

is the same as:

void f() {
    extern int i;
}

because the prior declaration int i specifies no linkage because paragraph 6 says:

The following identifiers have no linkage: an identifier declared to be anything other than an object or a function; an identifier declared to be a function parameter; a block scope identifier for an object declared without the storage-class specifier extern.

prior declaration specifies internal or external linkage

extern int i;
void f() {
    extern int i;
}

is the same as:

extern int i;
void f() {}

and:

static int i;
void f() {
    extern int i;
}

is the same as:

static int i;
void f() {}

because in both cases we have a previous visible external and internal (static) linkage declarations respectively.

Initialize local extern

Invalid C:

void f() {
    extern int i = 0;
}

because the block scope declaration has an initialization.

Valid C:

extern int i = 0;
void f() {}

but arguably bad style because equivalent to the shorter:

int i = 0;
void f() {}

because 6.7.8 Initialization says:

If the declaration of an identifier has block scope, and the identifier has external or internal linkage, the declaration shall have no initializer for the identifier.

1. Can local variables be declared extern?

No. But a global variable can be declared extern locally.

// file1.c
int Count;

// file2.c
void foo(void) {
  extern int Count;
  Count++;
}

2. Can register variables be declared extern?

No. A variable may not be extern and register.

C11 dr 6.7.1 Storage-class specifiers
1 storage-class-specifier:
typedef
extern
static
_Thread_local
auto
register
Constraints
2 At most, one storage-class specifier may be given in the declaration specifiers in a declaration, except that _Thread_local may appear with static or extern)

6.9 External definitions of C99 states:

The storage-class specifiers auto and register shall not appear in the declaration specifiers in an external declaration.

You only are allowed to define a global variable as extern. Telling the compiler (and linker) that it is defined elsewhere.

A local variable only exist in the local scope, as it is created on the stack or in a register. When the execution is not in the scope (anymore) the stack is unrolled (so free space becomes available again) or the register is used for other things, and the variable does not exist (anymore).

So defining a local extern would be 'weird' and impossible (due to the stack usage).

The phrase register variable is not clearly to me, so I would take one bold guess on what OP is really curious about, and rephrase the original question as: Could local variables be declared with extern specifier?, illustrated by the following snippet:

int main() {
    extern int x; // Is this OK?
    return 0;
}

The answer is yes.

scope (visibility) and storage are two independent and connected concept. Here, x is one local variable (scope), and it's only visible within this block. extern dictates the storage, meaning this is merely one declaration, this variable is defined somewhere else. Would recommend the C standard for definite reference.

As for the omitted register part, I assume OP meant one variable with register storage-class-specifier, like register int x. Then, it's illegal to specify register and extern at the same time.

int main() {
    extern auto int x; // This is wrong.
    return 0;
}

At most, one storage-class specifier may be given in the declaration specifiers in a declaration, except that _Thread_local may appear with static or extern.

The symmetric question would be: is it valid to specify auto or register with global or external variables, and this is exactly what Alexey Frunze's answer is about.

auto int x; // This is wrong.
int main() {
    return 0;
}