src/source_map.cc

// Copyright 2024 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "bloaty.h"
#include "source_map.h"
#include "util.h"

namespace bloaty {
namespace sourcemap {

static bool ReadOpeningBrace(std::string_view* data) {
  return ReadFixed<char>(data) == '{';
}

static std::string_view ReadQuotedString(std::string_view* data) {
  RequireChar(data, '\"');
  // Simply read until the next '\"'. We currently do not handle escaped
  // characters. Field names never contain quotes and file names are unlikely to
  // contain quotes.
  return ReadUntilConsuming(data, '\"');
}

// Finds the field with the given name in the source map. Any fields encountered
// before the field are skipped.
static void FindField(std::string_view* data, const char* name) {
  while (!data->empty()) {
    SkipWhitespace(data);
    auto field_name = ReadQuotedString(data);
    if (field_name == name) {
      SkipWhitespace(data);
      RequireChar(data, ':');
      SkipWhitespace(data);
      return;
    }

    // Skip until the next quote. We don't expect any structures involving
    // quotes in the fields that we skip.
    ReadUntil(data, '\"');
  }
  THROWF("field \"$0\" not found in source map", name);
}

static int32_t ReadBase64VLQ(std::string_view* data) {
  uint32_t value = 0;
  uint32_t shift = 0;
  const char* ptr = data->data();
  const char* limit = ptr + data->size();
  while (ptr < limit) {
    auto ch = *(ptr++);
    // Base64 characters A-Z, a-f do not have the continuation bit set and are
    // the last digit.
    if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch < 'g')) {
      uint32_t digit = ch < 'a' ? ch - 'A' : ch - 'a' + 26;
      value |= digit << shift;
      data->remove_prefix(ptr - data->data());
      return value & 1
          ? -static_cast<int32_t>(value >> 1)
          : static_cast<int32_t>(value >> 1);
    }
    if (!(ch >= 'g' && ch <= 'z') && !(ch >= '0' && ch <= '9') && ch != '+' &&
        ch != '/') {
      THROWF("Invalid Base64VLQ digit $0", ch);
    }
    // Base64 characters g-z, 0-9, + and / have the continuation bit set and
    // must be followed by another digit.
    uint32_t digit =
      ch > '9' ? ch - 'g' : (ch >= '0' ? ch - '0' + 20 : (ch == '+' ? 30 : 31));
    value |= digit << shift;
    shift += 5;
  }

  THROW("Unterminated Base64VLQ");
}

static bool IsBase64Digit(char ch) {
  return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
         (ch >= '0' && ch <= '9') || ch == '+' || ch == '/';
}

static int ReadBase64VLQSegment(std::string_view* data, int32_t (&values)[5]) {
  for (int i = 0; i < 5; i++) {
    values[i] = ReadBase64VLQ(data);
    if (data->empty() || !IsBase64Digit(data->front())) {
      if (i != 0 && i != 3 && i != 4) {
        THROWF("Invalid source map VLQ segment length $0", i + 1);
      }
      return i + 1;
    }
  }
  THROW("Unterminated Base64VLQ segment");
}

class VlqSegment {
 public:
  int32_t col;
  int32_t length;

  std::string source_file;
  int32_t source_line;
  int32_t source_col;

  VlqSegment(int32_t col, int32_t length,
             std::string_view source_file,
             int32_t source_line, int32_t source_col)
      : col(col), length(length),
        source_file(source_file),
        source_line(source_line), source_col(source_col) {}

  void addToSink(RangeSink* sink) const {
    auto name = sink->data_source() == DataSource::kInlines
        ? source_file + ":" + std::to_string(source_line)
        : source_file;
    sink->AddFileRange("sourcemap", name, col, length);
  }
};

template <class Func>
void ForEachVLQSegment(std::string_view* data,
                       const std::vector<std::string_view>& sources,
                       Func&& segment_func) {
  if (data->empty() || data->front() == '\"') {
    return;
  }

  // Read the first segment. We don't generate the `VlqSegment` until the next
  // one is encountered. This one only points to a particular byte. The next
  // segment is required to determine the length.
  int32_t values[5];
  int values_count = ReadBase64VLQSegment(data, values);
  if (values_count < 4) {
    THROW("Source file info expected in first VLQ segment");
  }
  int32_t col = values[0];
  int32_t source_file = values[1];
  int32_t source_line = values[2];
  int32_t source_col = values[3];

  while (!data->empty() && data->front() != '\"') {
    if (data->front() == ',') {
      data->remove_prefix(1);
      continue;
    }

    // We don't support line separators in the source map for now.
    if (data->front() == ';') {
      THROW("Unsupported line separator in source map");
    }

    int new_values_count = ReadBase64VLQSegment(data, values);
    if (values_count >= 4) {
      segment_func(VlqSegment(col, values[0],
                              sources[source_file], source_line, source_col));
    }
    values_count = new_values_count;
    col += values[0];
    if (values_count >= 4) {
      source_file += values[1];
      source_line += values[2];
      source_col += values[3];
    }
  }
}

static void ProcessToSink(std::string_view data, RangeSink* sink) {
  ReadOpeningBrace(&data);

  std::vector<std::string_view> sources;
  FindField(&data, "sources");
  RequireChar(&data, '[');
  while (!data.empty()) {
    SkipWhitespace(&data);
    if (data.empty()) {
      break;
    }
    if (data.front() == ']') {
      data.remove_prefix(1);
      break;
    }
    if (data.front() == ',') {
      data.remove_prefix(1);
    }
    auto source = ReadQuotedString(&data);
    sources.push_back(source);
  }
  SkipWhitespace(&data);
  RequireChar(&data, ',');

  FindField(&data, "mappings");
  RequireChar(&data, '\"');

  ForEachVLQSegment(&data, sources, [&sink](const VlqSegment& segment) {
    segment.addToSink(sink);
  });

  RequireChar(&data, '\"');
}

void SourceMapObjectFile::ProcessFileToSink(RangeSink* sink) const {
  if (sink->data_source() != DataSource::kCompileUnits
      && sink->data_source() != DataSource::kInlines) {
    THROW("Source map doesn't support this data source");
  }

  ProcessToSink(file_data().data(), sink);
}

}  // namespace sourcemap

std::unique_ptr<ObjectFile> TryOpenSourceMapFile(
    std::unique_ptr<InputFile>& file, std::string build_id) {
  std::string_view data = file->data();
  if (sourcemap::ReadOpeningBrace(&data)) {
    return std::unique_ptr<ObjectFile>(
        new sourcemap::SourceMapObjectFile(std::move(file), build_id));
  }

  return nullptr;
}

}  // namespace bloaty