code: def get_call_data(
      global_state: GlobalState,
      memory_start: Union[int, BitVec],
      memory_size: Union[int, BitVec],
  ):
      
      state = global_state.mstate
      transaction_id = "{}_internalcall".format(global_state.current_transaction.id)
  
      memory_start = cast(
          BitVec,
          (
              symbol_factory.BitVecVal(memory_start, 256)
              if isinstance(memory_start, int)
              else memory_start
          ),
      )
      memory_size = cast(
          BitVec,
          (
              symbol_factory.BitVecVal(memory_size, 256)
              if isinstance(memory_size, int)
              else memory_size
          ),
      )
  
      uses_entire_calldata = simplify(
          memory_size - global_state.environment.calldata.calldatasize == 0
      )
  
      if uses_entire_calldata is True:
          return global_state.environment.calldata
  
      try:
          calldata_from_mem = state.memory[
              util.get_concrete_int(memory_start) : util.get_concrete_int(
                  memory_start + memory_size
              )
          ]
          return ConcreteCalldata(transaction_id, calldata_from_mem)
      except TypeError:
          log.debug("Unsupported symbolic calldata offset")
          return SymbolicCalldata(transaction_id)
docs: Gets call_data from the global_state.
  
      :param global_state: state to look in
      :param memory_start: Start index
      :param memory_size: Size
      :return: Tuple containing: call_data array from memory or empty array if symbolic, type found