__static_initialization_and_destruction_0(int, int) () segmentation fault

I know similar questions have been asked, but I couldn't determine based on what I've seen why I'm getting this error.

This is the backtrace:

The definition of SymbolStack (in Symbols.h):

#ifndef HW3_SYMBOLS_H
#define HW3_SYMBOLS_H

#include <string>
#include <vector>
#include <iostream>
#include "shared_def.h"

using std::vector; using std::string;
extern int yylineno;

...

class SymbolStack {
public:
    vector<int> pos_stack = vector<int>();
    vector<SymbolTable*> scope_stack = vector<SymbolTable*>();
public:
    SymbolStack();
    ErrorType is_func_valid(const string& func_name, const string& retype, vector<string>* params_types, bool is_override);
    void push(bool is_while, Types retType = T_NONE);
    void pop();
    SymbolTable* get_curr_scope();
    void symbol_document(const string& symbol_name,const string& symbol_type, bool is_func = false,
                         bool is_over = false, vector<string>* func_params_types = nullptr); // add new symbol to the stack
    void func_param_document(const string& symbol_name, const string& symbol_type, int pos); // add new function to the stack
    bool symbol_exists(const string& symbol_name); // does a symbol exists?
    SymbolEntry* get_symbol(const string& symbol_name);
    SymbolEntry* get_func_symbol(const string& func_name, const string& retype, vector<string>* params_types, int* count); // if retype == "" error if count >= 2
   // bool function_exists(const string& name, vector<string>* params_types = nullptr);
    bool check_program();
    ~SymbolStack();
};

...

#endif //HW3_SYMBOLS_H

Types is an enum defined in shared_def.h.
The methods in Symbols.cpp:

SymbolStack::SymbolStack(){
    pos_stack.push_back(0); // init to offset = zero
    this->push(false, T_VOID);
    vector<string> print_param = vector<string>();
    vector<string> printi_param = vector<string>();
    print_param.push_back("string");
    printi_param.push_back("int");
    this->symbol_document("print", "void", FUNC, &print_param);
    this->symbol_document("printi", "void", FUNC, &printi_param);
}
void SymbolStack::push(bool is_while, Types retType){
    retType = retType == T_NONE? scope_stack.back()->ret_type : retType;
    SymbolTable* first_scope = new SymbolTable(pos_stack.back(), is_while, retType);
    pos_stack.push_back(pos_stack.back());
    scope_stack.push_back(first_scope);
}

The constructor of SymbolStack is called in parser.ypp:

%{
    #include <stdio.h>
    #include <iostream>
    #include "types.h"
    #include "hw3_output.hpp"
    extern int yylineno;
    extern int yylex();
    int yyerror(const char* message);
    extern SymbolStack tables;
%}

definitions...
%%
Rule...
%%

tables = SymbolStack();
int main(){
        int res = yyparse();
        bool is_valid_program = tables.check_program();
        if(!is_valid_program){
            output::errorMainMissing();
            exit(0);
        }
        tables.pop();
        return res;
}
int yyerror(const char * message){
	output::errorSyn(yylineno);
	exit(0);
}

I didn't manage to debug it using gdb because it happens even before main is called. It also happens if I remove this line "this->push(false, T_VOID);" from the constructor.

Any help would be appreciated.

EDIT: There is nothing in any source file I use that is defined as static.

> I didn't manage to debug it using gdb because it happens even before main is called.

1. GDB is perfectly capable of debugging crashes which happen before main.
2. You show GDB output (but your code is built without debugging (-g)).

> There is nothing in any source file I use that is defined as static.

You have a global tables variable. It is very likely that the crash is happening during that variable's initialization.

Without http://stackoverflow.com/help/mcve there isn't much help we can offer.

But you should be able to debug this yourself by re-building with -g and setting a breakpoint on SymbolStack::SymbolStack.

The only thing I can think of is that if T_VOID == T_NONE, then this line:

    retType = retType == T_NONE? scope_stack.back()->ret_type : retType;

will use non-existent scope_stack.back() (scope_stack is still empty), and that should crash.

P.S. To understand the crash, it is often helpful to examine the crashing instruction ((gdb) x/i $pc) and register values ((gdb) info regs).