Serialize SIL witness-tables and v-tables if package cmo is enabled.

[elsh]

Serialize SIL witness-tables and v-tables and their entries if package cmo is
enabled. If two modules are in the same package and package cmo is enabled,
v-table or witness-table calls should not be generated at the use site in the
client module. Modified conformance serialization check to allow serializing
witness thunks.

Also reordered SIL functions bottom-up so the most nested referenced functions
can be serialized first. Allowed serializing a function if it's a shared definition
(e.g. function print). Added a check for resilient modes and loadable types.

Added tests for SIL tables and resilient mode on/off.

rdar://124632670

[elsh]

@swift-ci smoke test

[elsh]

@swift-ci smoke test

[elsh]

@swift-ci smoke test

[elsh]

@swift-ci smoke test

[elsh]

Without this, witness thunks for conformance with package linkage don't get proper linkages in SILGenConformance::addMethodImplementation(..); they are defaulted to private otherwise and an attempt to serialize during package-cmo would lead to an assert fail.

[elsh]

@swift-ci smoke test

[aschwaighofer]

Unrelated to your PR. But I noticed something in the following code:

bool CrossModuleOptimization::canSerializeFunction(                             
                               SILFunction *function,                           
                               FunctionFlags &canSerializeFlags,                
                               int maxDepth) {                                  
  auto iter = canSerializeFlags.find(function);                                 
  // Avoid infinite recursion in case it's a cycle in the call graph.           
  if (iter != canSerializeFlags.end())                                          
    return iter->second;                                                        
                                                                                
  // Temporarily set the flag to false (to avoid infinite recursion) until we set
  // it to true at the end of this function.                                    
  canSerializeFlags[function] = false;                                          
                                                                                
  if (everything) {                                                             
   canSerializeFlags[function] = true;                                          
   return true;                                                                 
  }                                                                             
                                                                                
  if (DeclContext *funcCtxt = function->getDeclContext()) {                     
    if (!canUseFromInline(funcCtxt))                                            
      return false;                                                             
  }                                                                             
                                                                                
  if (function->isSerialized())                                                 
    return true;  

The first time we call the canSerializeFunction function me might end up in the if (function->isSerialized()) branch. But the second time we call canSerializeFunction on the same function we will end up in the cached value which returns false because of the earlier:

  // Temporarily set the flag to false (to avoid infinite recursion) until we set
  // it to true at the end of this function.                                    
  canSerializeFlags[function] = false;   

This seems to be an oversight/ unnecessary pessimistic. I think we should change the code to:

  if (function->isSerialized()) {
    canSerializeFlags[function] = true;                                               
    return true; 
  }

[elsh]

@swift-ci smoke test

[aschwaighofer]

LGTM