Q:

How is the r-value reference being passed in here?

void test(vector<int> v) {
    for(int i:v) cout<< i<<" ";
}
int main()
{
    vector<int> v{ 1,2,3 };
    test(move(v));
    cout << "v is gone...."; 
}

I am new to move semantics and rvalue references. In the code above, the vector is printed. Clearly the move worked. 
What I don't understand is how it worked. Why don't I have to define a function that takes in an rvalue reference? My best guess is the compiler is generating this automatically:
void test(vector<int>&& v) {
    for(int i:v) cout<< i<<" ";
}

A:

You can create a vector with an r-value reference to it:
std::vector<int> a = {1, 2, 3};

std::vector<int> b = std::move(a); // Constructs b from r-value reference

This invokes std::vector's move constructor, which basically just copies the data pointer from the first vector to the second vector. 
When you invoke the function void test(std::vector<int> v) in your example, the same thing happens: the compiler calls std::vector's move constructor, and creates a new vector in the stack space allocated for the parameter v. No functions are implicitly generated. 
The difference between void test(std::vector<int> v), and void test(std::vector<int>&& v). 
In the first case, you're passing the vector by value. That means that whenever you call test, the function calling test allocates space for a new vector on the stack before invoking test. It has to call std::vector's constructor, and in the process, it either 

moves a vector; 
copies a vector; or 
magically constructs the vector in-place (this happens if you construct the vector at the site where you call test, for example in test(std::vector<int>{1, 2, 3}))

On the other hand, test(std::vector<int>&& v) takes the argument by reference. This means that when you call this version of test by moving a variable, no new vector gets created. Whatever vector you give it is passed by reference, and as a result any changes that test(std::vector<int>&&) makes to the vector will show up on the original. 
For example:
// Even though v is passed as an r-value reference, 
// v is never moved-from inside test(). An object is only moved-from
// If an r-value reference to it is used to construct a new object. 
void test(std::vector<int>&& v) {
    v.push_back(4); 
}

std::vector<int> myList = {1, 2, 3}; 
test(std::move(myList)); // Adds 4 to the end of myList

// Prints 1 2 3 4
for(int i : myList) {
    std::cout << i << " ";
}

